BestHub
Sign in
Tagged articles

ThreadPool

369 articles · Page 1 of 4
Java Tech Workshop
Java Tech Workshop
Jun 10, 2026 · Backend Development

Mastering SpringBoot @Async: Thread‑Pool Configuration, Pitfalls, and Best Practices

The article explains why @Async, the most used async solution in SpringBoot, often causes OOM, missing trace IDs, silent failures, and task avalanches, and then walks through the underlying AOP mechanism, thread‑pool choices, timeout handling, context propagation, transaction interactions, monitoring, and dynamic tuning.

CompletableFutureMDCThreadPool
0 likes · 13 min read
Mastering SpringBoot @Async: Thread‑Pool Configuration, Pitfalls, and Best Practices
Java Architect Essentials
Java Architect Essentials
Jun 8, 2026 · Backend Development

How to Configure a ThreadPool to Send 10 Million SMS in One Hour (Java)

The article walks through calculating the required QPS for 10 million SMS in an hour, derives a precise ThreadPoolExecutor configuration (core 200, max 500, queue 5000, 60 s keep‑alive, CallerRunsPolicy), and provides complete Spring Boot code with production tips such as pagination, retry, idempotency and rate‑limiting.

JavaSpring BootThreadPool
0 likes · 7 min read
How to Configure a ThreadPool to Send 10 Million SMS in One Hour (Java)
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 6, 2026 · Backend Development

Stop Misusing @Async: 4 Advanced Async Rules Every Senior Developer Should Follow

The article explains why careless use of Spring Boot’s @Async can cause thread‑pool exhaustion, silent failures, and transaction inconsistencies, and presents four advanced patterns—custom thread pools, CompletableFuture parallelism, @TransactionalEventListener, and AsyncUncaughtExceptionHandler—to use @Async safely and observably.

AsyncUncaughtExceptionHandlerCompletableFutureSpring Boot
0 likes · 13 min read
Stop Misusing @Async: 4 Advanced Async Rules Every Senior Developer Should Follow
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 5, 2026 · Backend Development

5 Advanced Java Concurrency Tricks That Can Triple Your Throughput

This article walks through five proven Java 21 concurrency tuning techniques—including non‑blocking CompletableFuture pipelines, StampedLock for read‑heavy workloads, bounded queues with CallerRunsPolicy, atomic computeIfAbsent usage in ConcurrentHashMap, and correct virtual‑thread patterns—showing how each can dramatically improve throughput and stability in high‑load systems.

CompletableFutureJavaStampedLock
0 likes · 9 min read
5 Advanced Java Concurrency Tricks That Can Triple Your Throughput
Java Architect Handbook
Java Architect Handbook
Apr 29, 2026 · Backend Development

How Many Ways Can You Create a ThreadPool in Java? Interview Essentials

The article explains the four ways to create a thread pool in Java, why the Executors factory methods are unsafe for production, how to manually configure ThreadPoolExecutor with its seven parameters, and compares scheduled and ForkJoin pools while providing interview‑focused Q&A and practical configuration formulas.

ExecutorsForkJoinPoolJava
0 likes · 14 min read
How Many Ways Can You Create a ThreadPool in Java? Interview Essentials
Java Tech Workshop
Java Tech Workshop
Apr 7, 2026 · Backend Development

Mastering SpringBoot @Scheduled: Static and Dynamic Scheduling Explained

This article walks through SpringBoot's built‑in scheduling, comparing static @Scheduled tasks with dynamic Trigger‑based jobs, covering configuration, cron syntax, thread‑pool setup, async execution, runtime cron updates, exception handling, and practical best‑practice recommendations for production systems.

DynamicSchedulingExceptionHandlingScheduledTasks
0 likes · 14 min read
Mastering SpringBoot @Scheduled: Static and Dynamic Scheduling Explained
Senior Tony
Senior Tony
Mar 16, 2026 · Backend Development

Prioritize Max Threads Before Queue in Java ThreadPool – Interview‑Ready Trick

This guide explains the default Java ThreadPoolExecutor workflow, identifies why interview questions may require launching maximum threads before queuing tasks, and presents a concise two‑pool plus custom rejection‑policy solution that satisfies the requirement without writing a custom thread pool from scratch.

ExecutorJavaThreadPool
0 likes · 5 min read
Prioritize Max Threads Before Queue in Java ThreadPool – Interview‑Ready Trick
JavaGuide
JavaGuide
Feb 11, 2026 · Backend Development

Do ThreadLocal Values Fail in Asynchronous Scenarios? An Interviewer's Trick Question Explained

This article explains why ThreadLocal values are not automatically transferred in asynchronous or thread‑pool contexts, compares JDK's InheritableThreadLocal with Alibaba's TransmittableThreadLocal (TTL), and shows how TTL captures, replays, and restores context safely with code examples and diagrams.

Context propagationInheritableThreadLocalJava concurrency
0 likes · 13 min read
Do ThreadLocal Values Fail in Asynchronous Scenarios? An Interviewer's Trick Question Explained
Top Architect
Top Architect
Feb 4, 2026 · Backend Development

Build a Robust Asynchronous Processing SDK with Spring, Kafka and MySQL

This article introduces a generic asynchronous processing SDK for Java back‑ends, explaining its design principles, advantages, component architecture, database schema, configuration via Apollo, usage steps, and practical demonstrations, while providing complete code snippets and a GitHub repository for reference.

AsynchronousJavaSpring
0 likes · 12 min read
Build a Robust Asynchronous Processing SDK with Spring, Kafka and MySQL
java1234
java1234
Jan 24, 2026 · Fundamentals

How to Detect Completion of Thread Pool Tasks in Java

This article explains four practical ways to determine when tasks submitted to a Java ExecutorService have finished—using Future's isDone/get, ExecutorService.invokeAll, CompletionService, and CountDownLatch—each with code examples and usage guidance.

CompletionServiceCountDownLatchExecutorService
0 likes · 8 min read
How to Detect Completion of Thread Pool Tasks in Java
Su San Talks Tech
Su San Talks Tech
Jan 5, 2026 · Backend Development

Master Java ThreadPool Interview Questions: Core Concepts, Parameters, and Best Practices

This guide compiles the most common Java thread‑pool interview questions, explains why and how thread pools are used, details the core parameters and execution flow of ThreadPoolExecutor, explores internal locks, usage patterns, monitoring, rejection policies, common pitfalls, and introduces the DynamicTp management framework.

BlockingQueueJUCJava
0 likes · 32 min read
Master Java ThreadPool Interview Questions: Core Concepts, Parameters, and Best Practices
Su San Talks Tech
Su San Talks Tech
Dec 24, 2025 · Backend Development

Fixing RabbitMQ Connection Leaks with Thread‑Pool Asynchrony

Facing frequent timeouts in the high‑traffic eLong red‑envelope API, we traced the root cause to a RabbitMQ SDK connection‑leak using Linux netstat, then resolved it by offloading the processing to a single‑threaded pool, eliminating blocking and avoiding the SDK bug.

ConnectionLeakJavaRabbitMQ
0 likes · 7 min read
Fixing RabbitMQ Connection Leaks with Thread‑Pool Asynchrony
macrozheng
macrozheng
Dec 22, 2025 · Backend Development

Why Your Java ThreadPool Threads Aren’t Releasing and How Shutdown Fixes It

The article investigates a Java application that accumulated nearly a thousand waiting threads without high CPU or memory usage, identifies a custom FixedThreadPool as the cause, explains how thread pools become GC roots, and demonstrates that calling shutdown or shutdownNow properly releases both threads and the pool.

ExecutorServiceGarbageCollectionJVM
0 likes · 13 min read
Why Your Java ThreadPool Threads Aren’t Releasing and How Shutdown Fixes It
Su San Talks Tech
Su San Talks Tech
Nov 27, 2025 · Backend Development

DynamicTp: Real‑Time, Zero‑Intrusion ThreadPoolExecutor Tuning for Java Services

DynamicTp is an open‑source SpringBoot starter that lets developers monitor, alert on, and adjust ThreadPoolExecutor parameters at runtime via popular configuration centers, offering zero‑intrusion integration, extensible metrics, multi‑channel notifications, and support for a wide range of middleware thread pools.

JavaMonitoringThreadPool
0 likes · 11 min read
DynamicTp: Real‑Time, Zero‑Intrusion ThreadPoolExecutor Tuning for Java Services
Senior Tony
Senior Tony
Nov 18, 2025 · Backend Development

Mastering Java Thread Pools: 7 Critical Pitfalls Every Engineer Should Know

This article breaks down seven common thread‑pool pitfalls frequently asked in Java interviews, explains core‑thread reclamation, warm‑up, pool states, task‑completion checks, the risks of the default ForkJoinPool, and when to use single, fixed, or cached thread‑pool executors.

JavaJavaInterviewThreadPool
0 likes · 6 min read
Mastering Java Thread Pools: 7 Critical Pitfalls Every Engineer Should Know
JavaGuide
JavaGuide
Nov 16, 2025 · Backend Development

ByteDance Backend Interview: Java OOM, ThreadPool Tuning, Redis & MQ

ByteDance’s recent salary announcements show higher offers up to 40K, while the company’s rigorous backend interview covers Java heap OOM analysis, JVM tuning, thread‑pool configuration, Redis expiration strategies, MQ usage, network request flow, and algorithm challenges, providing a comprehensive technical deep‑dive for candidates.

JVMJavaMessageQueue
0 likes · 24 min read
ByteDance Backend Interview: Java OOM, ThreadPool Tuning, Redis & MQ
Top Architect
Top Architect
Nov 8, 2025 · Backend Development

Mastering High‑Throughput Thread Pools: Strategies for 100k QPS in Java

This article analyzes a high‑traffic scenario where 100,000 QPS requests each require 100 ms processing, explains why a naïve fixed thread pool would exhaust resources, and presents practical optimization goals, strategies, and Spring‑Boot code examples—including custom pool parameters, rejection handling, batch processing, and advanced techniques like Disruptor and rate‑limiting—to build a stable, high‑performance task execution system.

Performance OptimizationSpring BootThreadPool
0 likes · 8 min read
Mastering High‑Throughput Thread Pools: Strategies for 100k QPS in Java
JavaGuide
JavaGuide
Nov 4, 2025 · Backend Development

JD Backend Salary Ranges 2024 & How to Ace the Interview

The article shares recent JD backend salary data ranging from 24k to 32k RMB per month, explains the compensation structure, and provides a step‑by‑step interview preparation guide covering project presentation, JWT, Redis, thread pools, MySQL‑Elasticsearch sync, isolation levels and performance analysis.

Backend DevelopmentJDJWT
0 likes · 21 min read
JD Backend Salary Ranges 2024 & How to Ace the Interview
Architect's Tech Stack
Architect's Tech Stack
Sep 27, 2025 · Backend Development

Ensuring Transaction Rollback in Multi‑Threaded Java Services

This article explains why @Transactional fails in multi‑threaded Spring services, provides a utility for splitting large data sets, shows thread‑pool configuration, demonstrates a failing transaction scenario, and presents a solution using manual MyBatis sqlSession commit to guarantee atomic rollback across all threads.

JavaMyBatisSpring
0 likes · 10 min read
Ensuring Transaction Rollback in Multi‑Threaded Java Services
IT Services Circle
IT Services Circle
Sep 25, 2025 · Backend Development

Master Java Interviews: Overloading, HashMap, Thread Pools, GC & HTTP Essentials

This article combines practical advice for negotiating offers at Tonghuashun with a comprehensive Java interview cheat‑sheet covering method overloading vs overriding, final vs finally, sleep vs wait, HashMap insertion and resizing, reference types, HTTP request structure, status codes, thread‑pool parameters, and garbage‑collection algorithms.

GarbageCollectionHTTPHashMap
0 likes · 23 min read
Master Java Interviews: Overloading, HashMap, Thread Pools, GC & HTTP Essentials
Efficient Ops
Efficient Ops
Sep 16, 2025 · Backend Development

Why Tomcat Thread‑Pool Saturation Crashed Our Service and How to Avoid It

A detailed post‑mortem explains how a sudden traffic surge, insufficient pod count, and a custom thread‑pool bottleneck caused Tomcat thread‑pool saturation, health‑check failures, and a zone‑wide outage, and offers concrete lessons on capacity planning, monitoring, and safe coding practices.

CapacityPlanningJavaThreadPool
0 likes · 28 min read
Why Tomcat Thread‑Pool Saturation Crashed Our Service and How to Avoid It
Java Tech Enthusiast
Java Tech Enthusiast
Sep 16, 2025 · Backend Development

Master Java Concurrency & Redis: Thread Safety, Pools, and Data Consistency

This article explains Java thread‑safety concepts, how to use and configure ThreadPoolExecutor, Redis performance tricks, Zset internal structures, memory‑eviction policies, node‑failure handling, cache‑DB consistency patterns, and MySQL transaction ACID properties with MVCC differences, providing practical code examples throughout.

JavaRedisThreadPool
0 likes · 25 min read
Master Java Concurrency & Redis: Thread Safety, Pools, and Data Consistency
Java Backend Full-Stack
Java Backend Full-Stack
Sep 12, 2025 · Backend Development

How to Handle Exceptions Thrown by Threads in a ThreadPool

This article explains why tasks submitted to a Java ThreadPool via submit silently swallow exceptions while execute prints them, and demonstrates three practical ways—using Future.get(), a custom UncaughtExceptionHandler, and overriding afterExecute—to reliably capture and process those exceptions.

ExceptionHandlingExecutorServiceFuture
0 likes · 14 min read
How to Handle Exceptions Thrown by Threads in a ThreadPool
Java Backend Full-Stack
Java Backend Full-Stack
Sep 10, 2025 · Backend Development

How a Misconfigured ThreadPool Caused Data Loss in Production – A Step‑by‑Step Troubleshooting Guide

The article recounts a real production incident where a recent deployment triggered loss of third‑party order data, traces the root cause to an improperly configured ThreadPoolExecutor that used a local memory queue, and walks through the systematic investigation and remediation steps.

BlockingQueueJavaProductionDebugging
0 likes · 6 min read
How a Misconfigured ThreadPool Caused Data Loss in Production – A Step‑by‑Step Troubleshooting Guide
Architect
Architect
Sep 3, 2025 · Backend Development

Mastering Java Thread Pools: Deep Dive into ThreadPoolExecutor Architecture

This comprehensive guide explores Java thread pools, detailing their advantages, design concepts, core classes, constructors, task queues, rejection policies, lifecycle states, initialization, dynamic resizing, shutdown procedures, and the internal workings of ThreadPoolExecutor, Worker, and related methods with clear examples and diagrams.

ExecutorThreadPoolmultithreading
0 likes · 34 min read
Mastering Java Thread Pools: Deep Dive into ThreadPoolExecutor Architecture
Java Architect Essentials
Java Architect Essentials
Aug 19, 2025 · Backend Development

Mastering Asynchronous Requests in Spring Boot: Callable, WebAsyncTask & DeferredResult

This article explains how Spring Boot supports asynchronous request handling using Servlet 3.0 features, detailing four implementation approaches—Callable, WebAsyncTask, DeferredResult, and thread‑pool configuration—while outlining when async processing improves throughput and how to apply it effectively.

CallableDeferredResultThreadPool
0 likes · 10 min read
Mastering Asynchronous Requests in Spring Boot: Callable, WebAsyncTask & DeferredResult
Java Captain
Java Captain
Jul 16, 2025 · Backend Development

Ensuring Transaction Rollback in Multi‑Threaded Spring Batch Inserts

This article explains why the @Transactional annotation fails in multithreaded Spring batch insert scenarios, demonstrates the problem with code examples, and shows how to use SqlSession for manual commit and rollback to guarantee atomicity across all threads.

JavaMyBatisSpring
0 likes · 10 min read
Ensuring Transaction Rollback in Multi‑Threaded Spring Batch Inserts
Architect
Architect
Jun 3, 2025 · Backend Development

Implementing Asynchronous Requests in Spring Boot: Callable, WebAsyncTask, and DeferredResult

This article explains how Spring Boot supports asynchronous request handling after Servlet 3.0, compares four async mechanisms—AsyncContext, Callable, WebAsyncTask, and DeferredResult—provides code examples for each, discusses thread‑pool configuration, and outlines when asynchronous processing improves throughput.

AsynchronousCallableDeferredResult
0 likes · 11 min read
Implementing Asynchronous Requests in Spring Boot: Callable, WebAsyncTask, and DeferredResult
Top Architecture Tech Stack
Top Architecture Tech Stack
May 26, 2025 · Backend Development

Implementing Asynchronous Requests in Spring Boot: Callable, WebAsyncTask, and DeferredResult

This article explains how to implement asynchronous request handling in Spring Boot using four approaches—AsyncContext, Callable, WebAsyncTask, and DeferredResult—detailing their mechanisms, code examples, thread pool configuration, and when to choose async processing to improve throughput.

AsynchronousCallableDeferredResult
0 likes · 10 min read
Implementing Asynchronous Requests in Spring Boot: Callable, WebAsyncTask, and DeferredResult
Java Captain
Java Captain
May 12, 2025 · Fundamentals

Understanding Java Thread Pools: Design, Implementation, and Usage

This article explains the purpose, advantages, design principles, configuration parameters, task queue options, rejection policies, lifecycle management, and internal execution flow of Java's ThreadPoolExecutor, providing code examples and detailed insights into how thread pools work in concurrent applications.

ExecutorJavaThreadPool
0 likes · 30 min read
Understanding Java Thread Pools: Design, Implementation, and Usage
Ma Wei Says
Ma Wei Says
May 8, 2025 · Backend Development

Mastering Java ThreadPoolExecutor: Prevent OOM and Boost Concurrency

This article explains the fundamentals of Java threads and thread pools, details the configurable parameters of ThreadPoolExecutor, highlights the pitfalls of the Executors factory methods, and provides concrete recommendations and code examples for safely tuning thread pools across different workload types.

JavaThreadPoolThreadPoolExecutor
0 likes · 14 min read
Mastering Java ThreadPoolExecutor: Prevent OOM and Boost Concurrency
Cognitive Technology Team
Cognitive Technology Team
May 1, 2025 · Backend Development

10 Tips and Tricks for Using ExecutorService in Java

This article presents ten practical tips for Java developers on naming thread‑pool threads, dynamically changing thread names, safely shutting down executors, handling interruptions, bounding queue sizes, proper exception handling, monitoring wait times, preserving client stack traces, preferring CompletableFuture, and using SynchronousQueue with ThreadPoolExecutor.

ExecutorServiceJavaThreadPool
0 likes · 15 min read
10 Tips and Tricks for Using ExecutorService in Java
Cognitive Technology Team
Cognitive Technology Team
Apr 29, 2025 · Backend Development

Common CompletableFuture Pitfalls and Best Practices in Java

This article examines the powerful Java CompletableFuture class, identifies frequent misuse pitfalls such as ignored exceptions, wrong thread‑pool choices, blocking callbacks, context loss, and overly fragmented chains, and provides concrete avoidance strategies and best‑practice recommendations for robust asynchronous programming.

AsynchronousCompletableFutureJava
0 likes · 9 min read
Common CompletableFuture Pitfalls and Best Practices in Java
Java Captain
Java Captain
Apr 27, 2025 · Backend Development

Parallel Pagination Query Interceptor for MyBatis-Plus in Spring Boot

This article explains how to implement a custom MyBatis-Plus pagination interceptor that parallelizes COUNT and data queries using CompletableFuture and a configurable thread pool in Spring Boot, suitable for large single-table and complex multi-table pagination scenarios, and provides detailed configuration and code examples.

JavaParallel QuerySpring Boot
0 likes · 13 min read
Parallel Pagination Query Interceptor for MyBatis-Plus in Spring Boot
Java Captain
Java Captain
Apr 27, 2025 · Backend Development

Understanding Java Executors Thread Pools: newCachedThreadPool, newScheduledThreadPool, newSingleThreadExecutor, newWorkStealingPool, and newFixedThreadPool

This article explains the five main thread‑pool types provided by Java's Executors class, detailing their constructors, underlying queue implementations, and default thread‑count behaviors, and notes why the default pools may not suit everyday development needs.

ExecutorServiceExecutorsJava
0 likes · 4 min read
Understanding Java Executors Thread Pools: newCachedThreadPool, newScheduledThreadPool, newSingleThreadExecutor, newWorkStealingPool, and newFixedThreadPool
Sanyou's Java Diary
Sanyou's Java Diary
Apr 24, 2025 · Fundamentals

Master Java’s Concurrent Containers: Deep Dive into ConcurrentHashMap and Queues

This article provides an in‑depth exploration of Java’s concurrent collection classes, covering the design and implementation of ConcurrentHashMap, ConcurrentLinkedQueue, and the seven blocking queue variants, complete with code analysis, performance considerations, and practical usage scenarios for high‑throughput multithreaded applications.

BlockingQueueConcurrentLinkedQueueData Structures
0 likes · 50 min read
Master Java’s Concurrent Containers: Deep Dive into ConcurrentHashMap and Queues
Java Captain
Java Captain
Apr 22, 2025 · Backend Development

Implementing Asynchronous Calls in SpringBoot with @Async

This article explains why asynchronous programming improves concurrency in SpringBoot applications, describes how to enable @Async support, configure a custom ThreadPoolTaskExecutor, annotate methods for async execution, and outlines the underlying proxy mechanism that powers @Async.

AsyncJavaThreadPool
0 likes · 5 min read
Implementing Asynchronous Calls in SpringBoot with @Async
Cognitive Technology Team
Cognitive Technology Team
Apr 16, 2025 · Backend Development

Automatic Trace-Wrapped ThreadPool Instances in Spring Cloud

This article explains how Spring Cloud automatically wraps managed thread pool beans with trace-enabled proxies to preserve distributed tracing information, details the ExecutorBeanPostProcessor implementation, shows the relevant configuration and instrumentation code, and notes that manually created executors must be wrapped manually.

Backend DevelopmentInstrumentationJava
0 likes · 7 min read
Automatic Trace-Wrapped ThreadPool Instances in Spring Cloud
Programmer XiaoFu
Programmer XiaoFu
Apr 15, 2025 · Backend Development

Sync vs Async: Achieving 10× Throughput in SpringBoot APIs

The article explains how SpringBoot’s asynchronous request handling—using Callable, WebAsyncTask, and DeferredResult with a custom thread pool—can boost API throughput up to ten times compared to synchronous processing, while detailing the internal flow, configuration steps, and scenarios where async is beneficial.

CallableDeferredResultThreadPool
0 likes · 9 min read
Sync vs Async: Achieving 10× Throughput in SpringBoot APIs
Senior Tony
Senior Tony
Apr 15, 2025 · Backend Development

How to Size Java Thread Pools: CPU vs I/O Strategies and Dynamic ThreadPool Solutions

This article explains two common approaches for configuring Java thread pools—static sizing based on CPU‑bound or I/O‑bound workloads and a formula‑driven method—then critiques their limits in real systems and introduces DynamicTp as a flexible, monitoring‑enabled alternative with code examples and architectural details.

CPU BoundDynamicThreadPoolI/O Bound
0 likes · 8 min read
How to Size Java Thread Pools: CPU vs I/O Strategies and Dynamic ThreadPool Solutions
macrozheng
macrozheng
Mar 31, 2025 · Backend Development

9 Ways to Implement Asynchronous Programming in Java – From Threads to CompletableFuture

This tutorial enumerates nine Java asynchronous programming techniques—including Thread/Runnable, Executors, custom thread pools, Future/Callable, CompletableFuture, ForkJoinPool, Spring @Async, message queues, and Hutool ThreadUtil—explains their advantages and drawbacks, and provides complete code examples for each method.

CompletableFutureMQThreadPool
0 likes · 14 min read
9 Ways to Implement Asynchronous Programming in Java – From Threads to CompletableFuture
Code Ape Tech Column
Code Ape Tech Column
Mar 19, 2025 · Backend Development

ExecutorService vs CompletionService: In‑Depth Comparison and Practical Usage in Java

This article explains the differences between ExecutorService and CompletionService, demonstrates how to replace a simple Future‑based approach with CompletionService for faster result retrieval, analyzes the underlying source code, and outlines typical use‑cases such as load‑balancing and early‑return patterns in concurrent Java applications.

AsyncCompletionServiceExecutorService
0 likes · 12 min read
ExecutorService vs CompletionService: In‑Depth Comparison and Practical Usage in Java
IT Services Circle
IT Services Circle
Mar 13, 2025 · Backend Development

Common Pitfalls When Using CompletableFuture in Java

This article introduces the advantages of Java's CompletableFuture and systematically outlines six common pitfalls—including default thread‑pool issues, exception handling, timeout management, thread‑local context loss, callback hell, and task‑ordering problems—while providing correct code examples and best‑practice recommendations.

CompletableFutureExceptionHandlingJava
0 likes · 10 min read
Common Pitfalls When Using CompletableFuture in Java
Selected Java Interview Questions
Selected Java Interview Questions
Mar 10, 2025 · Backend Development

Postmortem of a Server Crash Caused by a Mis‑managed Scheduled Task in a Backend Module

The article analyzes a server outage triggered by a module that repeatedly created a scheduled task without proper lifecycle control, examines the problematic Java code, lists four key issues, presents a corrected implementation, and reflects on development, testing, review, and logging practices to prevent similar incidents.

LoggingScheduledExecutorServiceThreadPool
0 likes · 5 min read
Postmortem of a Server Crash Caused by a Mis‑managed Scheduled Task in a Backend Module
Raymond Ops
Raymond Ops
Mar 5, 2025 · Fundamentals

Master Python ThreadPool and ProcessPool: Boost Concurrency and Performance

This article explains Python's multithreading and multiprocessing concepts, compares thread pools and process pools, provides practical code examples for task execution and file downloading, and offers performance tips and best practices for writing efficient concurrent programs.

MultiprocessingPythonThreadPool
0 likes · 14 min read
Master Python ThreadPool and ProcessPool: Boost Concurrency and Performance
IT Services Circle
IT Services Circle
Mar 3, 2025 · Backend Development

Meituan Spring Hiring Overview and Java Backend Interview Q&A

This article discusses Meituan's spring recruitment numbers, then provides detailed Java backend interview questions and answers covering Spring MVC vs Spring Boot, MySQL MVCC, Redis Zset implementation, message queue reliability, HashMap internals, and thread pool usage, offering practical insights for candidates.

JavaSpringThreadPool
0 likes · 20 min read
Meituan Spring Hiring Overview and Java Backend Interview Q&A
Su San Talks Tech
Su San Talks Tech
Mar 3, 2025 · Backend Development

Mastering Java Thread Pools: Architecture, Parameters, and Customization

This article provides a comprehensive guide to Java thread pools, explaining their purpose, construction parameters, execution flow, worker reuse, task retrieval with timeout, lifecycle states, shutdown mechanisms, monitoring methods, and best practices for customizing pools in real-world projects.

ExecutorServiceJavaThreadPool
0 likes · 17 min read
Mastering Java Thread Pools: Architecture, Parameters, and Customization
FunTester
FunTester
Feb 14, 2025 · Fundamentals

Design and Implementation of a Multithreaded Task Class in Java for Performance Testing

This article explains the design and implementation of a flexible, extensible Java multithreaded task class for performance testing, covering the choice of Runnable over Thread, execution control mechanisms, data collection methods, and sample abstract code illustrating before, test, and after lifecycle hooks.

Abstract ClassAtomicBooleanJava
0 likes · 10 min read
Design and Implementation of a Multithreaded Task Class in Java for Performance Testing
FunTester
FunTester
Feb 6, 2025 · Backend Development

Choosing and Customizing Thread Pools for Java Performance Testing

This article explains how to select and customize a Java thread pool for performance testing, covering parameter considerations, modifications to the standard fixed thread pool, custom thread factories, work queue choices, and provides complete example code for both fixed and TPS models.

ExecutorServiceJavaPerformanceTesting
0 likes · 8 min read
Choosing and Customizing Thread Pools for Java Performance Testing
Programmer XiaoFu
Programmer XiaoFu
Feb 5, 2025 · Backend Development

Elegant Ways to Capture Exceptions from Java ThreadPool Tasks

This article explains why tasks submitted with ExecutorService.submit hide exceptions while execute prints them, demonstrates how Future.get() can retrieve hidden errors, and presents three practical solutions—inline try‑catch, a custom ThreadFactory with UncaughtExceptionHandler, and overriding afterExecute—to reliably handle thread‑pool exceptions in Java.

ExceptionHandlingExecutorServiceFuture
0 likes · 15 min read
Elegant Ways to Capture Exceptions from Java ThreadPool Tasks
Java Web Project
Java Web Project
Feb 1, 2025 · Backend Development

Choosing the Right Java Async Tool: Future, CompletableFuture, or FutureTask

This article compares three Java concurrency approaches—Future with Callable, CompletableFuture, and FutureTask—explaining their underlying principles, step‑by‑step usage, code examples, and trade‑offs so you can decide which asynchronous tool best fits your reporting workload.

CompletableFutureFutureFutureTask
0 likes · 10 min read
Choosing the Right Java Async Tool: Future, CompletableFuture, or FutureTask
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Jan 25, 2025 · Backend Development

Mastering CompletableFuture in Java: Basics, Advanced Features, and Best Practices

This comprehensive guide introduces Java's CompletableFuture, explains its advantages over the traditional Future API, demonstrates how to create and compose asynchronous tasks, manage thread pools, handle timeouts and cancellations, and apply robust exception handling techniques for reliable concurrent programming.

CompletableFutureFutureJava
0 likes · 16 min read
Mastering CompletableFuture in Java: Basics, Advanced Features, and Best Practices
Top Architect
Top Architect
Jan 21, 2025 · Backend Development

DynamicTp: A SpringBoot‑Based Dynamic Thread‑Pool Framework for Java Applications

The article introduces DynamicTp, a SpringBoot-based dynamic thread‑pool framework that enables real‑time adjustment, monitoring, and alerting of ThreadPoolExecutor parameters via various configuration centers, outlines its architecture, modules, features, and integration with third‑party components, and provides usage guidance for Java backend developers.

ConfigurationDynamicTpJava
0 likes · 12 min read
DynamicTp: A SpringBoot‑Based Dynamic Thread‑Pool Framework for Java Applications
Java Architect Essentials
Java Architect Essentials
Jan 19, 2025 · Backend Development

Proper Declaration, Monitoring, and Configuration of Java Thread Pools

This article explains how to correctly declare Java thread pools using ThreadPoolExecutor, monitor their runtime status, configure parameters for CPU‑bound and I/O‑bound workloads, assign meaningful names, avoid common pitfalls such as unbounded queues and thread‑local leakage, and leverage dynamic pool frameworks.

JavaThreadPoolThreadPoolExecutor
0 likes · 16 min read
Proper Declaration, Monitoring, and Configuration of Java Thread Pools
JD Tech Talk
JD Tech Talk
Jan 17, 2025 · Backend Development

Investigation of JSF Thread‑Pool Exhaustion During R2M Redis Upgrade

During a Redis version upgrade of the internal R2M cache service, a Biz thread‑pool exhaustion error was traced to JSF threads blocked on a read lock held by a topology‑updater task, revealing a deadlock caused by shared ForkJoinPool usage and missing lock timeouts.

JSFJavaRedis
0 likes · 5 min read
Investigation of JSF Thread‑Pool Exhaustion During R2M Redis Upgrade
Java Backend Technology
Java Backend Technology
Jan 9, 2025 · Backend Development

How DynamicTp Enables Real‑Time ThreadPool Tuning and Monitoring in Java

DynamicTp is a SpringBoot‑compatible framework that extends ThreadPoolExecutor to allow live adjustment of pool parameters, real‑time monitoring, multi‑platform alerts, and seamless integration with popular configuration centers, helping Java services achieve higher performance and reliability.

MicroservicesMonitoringThreadPool
0 likes · 11 min read
How DynamicTp Enables Real‑Time ThreadPool Tuning and Monitoring in Java
Java Tech Enthusiast
Java Tech Enthusiast
Dec 22, 2024 · Backend Development

Common Java ThreadPool Pitfalls and How to Avoid Them

Java developers should avoid ten common thread‑pool mistakes—such as using unbounded queues, misconfiguring thread counts, neglecting shutdown, ignoring rejection policies, swallowing task exceptions, submitting blocking work, overusing pools, lacking monitoring, and missing dynamic tuning—by configuring bounded queues, proper sizes, explicit policies, exception handling, and runtime adjustments.

JavaThreadPoolbest practices
0 likes · 8 min read
Common Java ThreadPool Pitfalls and How to Avoid Them
macrozheng
macrozheng
Dec 20, 2024 · Backend Development

Avoid the Top 10 Java ThreadPool Pitfalls and Boost Performance

This article explains ten common mistakes when using Java thread pools—such as unbounded queues, wrong thread counts, missing shutdown, and ignored exceptions—and provides concrete code examples and best‑practice solutions to help developers write safer, more efficient concurrent code.

JavaThreadPoolbackend
0 likes · 10 min read
Avoid the Top 10 Java ThreadPool Pitfalls and Boost Performance
FunTester
FunTester
Dec 19, 2024 · Backend Development

Mastering Custom Thread Pools: Choosing the Right Queue in Java

This article walks through Java thread‑pool queue options—LinkedBlockingQueue, SynchronousQueue, LinkedBlockingDeque, and PriorityBlockingQueue—explaining their characteristics, demonstrating code examples, and showing how to build multi‑priority executors with concrete output analysis.

BlockingQueueJavaLinkedBlockingDeque
0 likes · 12 min read
Mastering Custom Thread Pools: Choosing the Right Queue in Java
JD Tech Talk
JD Tech Talk
Dec 17, 2024 · Backend Development

What Happens When a Thread in a Java ThreadPool Throws an Exception?

This article experimentally compares how a Java ExecutorService thread pool reacts to uncaught exceptions when tasks are submitted via execute versus submit, showing that execute removes the faulty thread and creates a new one while submit retains the thread and stores the exception in a Future.

ExecutorServiceJavaThreadPool
0 likes · 7 min read
What Happens When a Thread in a Java ThreadPool Throws an Exception?
JD Cloud Developers
JD Cloud Developers
Dec 17, 2024 · Backend Development

What Happens When a Thread in a Java ThreadPool Throws an Exception?

This article examines how Java's ExecutorService thread pool reacts when a task throws an uncaught exception, comparing the behaviors of execute and submit methods, analyzing source code, and summarizing the impact on thread removal, creation, and exception retrieval.

ExceptionHandlingExecutorServiceJava
0 likes · 7 min read
What Happens When a Thread in a Java ThreadPool Throws an Exception?
FunTester
FunTester
Dec 17, 2024 · Backend Development

Mastering ThreadPool Exception Handling in Java: 5 Proven Techniques

This article examines why uncaught exceptions in Java thread pools cause runaway thread creation, then walks through five concrete strategies—try‑catch wrappers, Callable, afterExecute overrides, custom ThreadFactory, and a global default handler—each illustrated with runnable code and detailed analysis.

Backend DevelopmentJavaThreadPool
0 likes · 13 min read
Mastering ThreadPool Exception Handling in Java: 5 Proven Techniques
Su San Talks Tech
Su San Talks Tech
Dec 13, 2024 · Backend Development

Avoid the Top 10 Java ThreadPool Pitfalls and Boost Performance

This article explains ten common Java thread‑pool pitfalls—such as using Executors shortcuts, misconfiguring thread counts, ignoring queue choices, and neglecting shutdown or monitoring—and provides concrete code examples and best‑practice solutions to help developers write safer, more efficient concurrent code.

JavaThreadPoolbest practices
0 likes · 10 min read
Avoid the Top 10 Java ThreadPool Pitfalls and Boost Performance
FunTester
FunTester
Dec 4, 2024 · Backend Development

Mastering Custom ThreadPoolExecutor: Build Flexible Java Thread Pools

This article explains why the standard Executors factory methods may be insufficient, details each ThreadPoolExecutor constructor parameter, demonstrates how to configure a custom pool for performance testing, and walks through multiple code examples that illustrate thread creation, queue behavior, and rejection policies.

JavaJava concurrencyThreadPool
0 likes · 14 min read
Mastering Custom ThreadPoolExecutor: Build Flexible Java Thread Pools
FunTester
FunTester
Dec 2, 2024 · Fundamentals

Mastering Java Thread Pools: Fixed vs. Cached Executors Explained

This article explains Java thread pools, their performance benefits, and how to create and use FixedThreadPool and CachedThreadPool via the Executors utility, providing code examples, execution results, and guidance on selecting the appropriate pool for different concurrency scenarios.

CachedThreadPoolExecutorServiceFixedThreadPool
0 likes · 12 min read
Mastering Java Thread Pools: Fixed vs. Cached Executors Explained
Java Architect Essentials
Java Architect Essentials
Dec 1, 2024 · Backend Development

Resolving Execution Delay and Single‑Thread Issues in SpringBoot @EnableScheduling

This article explains why SpringBoot's default @EnableScheduling creates a single‑threaded scheduler that can cause execution delays, and demonstrates multiple solutions—including configuring the thread pool, using async execution, and applying a distributed lock with Redisson—to achieve reliable and concurrent scheduled tasks.

DistributedLockSchedulingThreadPool
0 likes · 17 min read
Resolving Execution Delay and Single‑Thread Issues in SpringBoot @EnableScheduling
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Dec 1, 2024 · Backend Development

Optimizing Million-Row Excel Export with EasyExcel: Design, Implementation, and Performance Tuning

This article presents a comprehensive guide to efficiently exporting millions of rows to Excel using EasyExcel, covering performance bottlenecks, resource consumption, asynchronous processing, thread‑pool design, batch querying, streaming writes, and practical code examples to achieve fast, memory‑friendly report generation.

EasyExcelExcel ExportJava
0 likes · 35 min read
Optimizing Million-Row Excel Export with EasyExcel: Design, Implementation, and Performance Tuning
FunTester
FunTester
Nov 26, 2024 · Backend Development

Understanding Java's ScheduledThreadPoolExecutor: Concepts, Configuration, Core Methods, and Best Practices

This article provides a comprehensive overview of Java's ScheduledThreadPoolExecutor, covering its fundamental concepts, inheritance, key features, construction options, core scheduling methods, configuration recommendations, common pitfalls, and practical code examples for reliable task scheduling in backend applications.

Backend DevelopmentJavaScheduledThreadPoolExecutor
0 likes · 9 min read
Understanding Java's ScheduledThreadPoolExecutor: Concepts, Configuration, Core Methods, and Best Practices
Top Architect
Top Architect
Nov 21, 2024 · Backend Development

Best Practices and Common Pitfalls of Using Thread Pools in Java

This article summarizes how to correctly declare, monitor, configure, and name Java thread pools, explains common mistakes such as unbounded queues and ThreadLocal contamination, and introduces dynamic tuning techniques and open‑source solutions for robust backend concurrency management.

JavaThreadLocalThreadPool
0 likes · 18 min read
Best Practices and Common Pitfalls of Using Thread Pools in Java
Top Architecture Tech Stack
Top Architecture Tech Stack
Nov 19, 2024 · Backend Development

Understanding Java ThreadPool Rejection Policies and Their Use Cases

This article explains the conditions that trigger Java thread‑pool rejection policies, describes the four built‑in policies (AbortPolicy, CallerRunsPolicy, DiscardPolicy, DiscardOldestPolicy), provides detailed code examples for each, and discusses suitable application scenarios for backend developers.

Backend DevelopmentJavaRejectionPolicy
0 likes · 13 min read
Understanding Java ThreadPool Rejection Policies and Their Use Cases
Top Architecture Tech Stack
Top Architecture Tech Stack
Nov 11, 2024 · Backend Development

Implementing Asynchronous Requests in Spring Boot: Callable, WebAsyncTask, and DeferredResult

This article explains how Spring Boot supports asynchronous request handling after Servlet 3.0, demonstrates three practical approaches—Callable, WebAsyncTask, and DeferredResult—with code examples, shows how to configure a custom thread pool, and discusses when asynchronous processing improves throughput.

CallableDeferredResultSpring Boot
0 likes · 10 min read
Implementing Asynchronous Requests in Spring Boot: Callable, WebAsyncTask, and DeferredResult
FunTester
FunTester
Oct 31, 2024 · Backend Development

Understanding Java ExecutorService: Core Concepts, Thread Pools, and Practical Usage

This article explains how Java's ExecutorService abstracts and simplifies asynchronous task execution, covering core features, thread‑pool configurations, task submission methods, future management, shutdown procedures, rejection policies, and real‑world code examples for network requests, image processing, and background tasks.

AsynchronousExecutorServiceJava
0 likes · 20 min read
Understanding Java ExecutorService: Core Concepts, Thread Pools, and Practical Usage
Top Architect
Top Architect
Oct 17, 2024 · Backend Development

Understanding ForkJoinPool and the Fork/Join Framework in Java

This article explains the limitations of ThreadPoolExecutor, introduces the Fork/Join model and ForkJoinPool, demonstrates how to implement divide‑and‑conquer tasks with RecursiveTask, analyzes the pool’s design, task submission methods, work‑stealing mechanism, common pool pitfalls, and presents performance evaluation results.

DivideAndConquerForkJoinPoolJava
0 likes · 26 min read
Understanding ForkJoinPool and the Fork/Join Framework in Java
Architect
Architect
Oct 9, 2024 · Backend Development

Unlocking Higher Throughput: Mastering Async Requests in Spring Boot

This article explains how Spring Boot can handle HTTP requests asynchronously using Callable, WebAsyncTask, and DeferredResult, detailing the underlying servlet workflow, thread‑pool configuration, and when asynchronous processing truly improves throughput versus CPU‑bound workloads.

CallableDeferredResultServlet
0 likes · 12 min read
Unlocking Higher Throughput: Mastering Async Requests in Spring Boot
Architect
Architect
Oct 8, 2024 · Backend Development

How to Supercharge Java Backend Performance with CompletableFuture, Thread Pools, Caching, and Lock Tuning

This article analyzes Java performance bottlenecks and demonstrates how to use CompletableFuture for parallelism, fine‑tune ThreadPoolExecutor parameters, minimize transaction scope, apply cache‑line padding, object pooling, lock‑granularity techniques, copy‑on‑write collections, and reduce network payloads to achieve lower latency and higher throughput.

CachingCompletableFutureJava
0 likes · 38 min read
How to Supercharge Java Backend Performance with CompletableFuture, Thread Pools, Caching, and Lock Tuning
Architecture Digest
Architecture Digest
Sep 15, 2024 · Backend Development

Implementing Asynchronous Requests in Spring Boot: Callable, WebAsyncTask, and DeferredResult

This article explains how to implement asynchronous request handling in Spring Boot using four approaches—AsyncContext, Callable, WebAsyncTask, and DeferredResult—detailing their mechanisms, code examples, thread pool configuration, and when to apply asynchronous processing to improve throughput.

CallableDeferredResultSpring Boot
0 likes · 10 min read
Implementing Asynchronous Requests in Spring Boot: Callable, WebAsyncTask, and DeferredResult
Java Interview Crash Guide
Java Interview Crash Guide
Sep 5, 2024 · Backend Development

Mastering Java Thread Pools: Best Practices and Configuration Guide

This article explains why using raw Thread or Runnable is discouraged in Java, introduces the core java.util.concurrent thread‑pool classes, compares the built‑in Executors factories, and provides detailed guidance on customizing ThreadPoolExecutor parameters, sizing strategies, rejection policies, hooks, shutdown procedures, and additional optimizations for robust production use.

ExecutorServiceJavaThreadPool
0 likes · 12 min read
Mastering Java Thread Pools: Best Practices and Configuration Guide
JavaEdge
JavaEdge
Sep 5, 2024 · Backend Development

Mastering Spring Boot Thread Pools: From Default Config to Custom Solutions

This article explains how Spring Boot automatically configures a ThreadPoolTaskExecutor for @Async and @Scheduled, shows the default parameters introduced in version 2.1, demonstrates how to inspect and customize them, compares the default executor with SimpleAsyncTaskExecutor, and provides code examples for using @Async, injecting the executor, and defining a custom thread pool to avoid resource‑exhaustion issues.

AsyncSpring BootTaskExecutionAutoConfiguration
0 likes · 18 min read
Mastering Spring Boot Thread Pools: From Default Config to Custom Solutions
Java Architect Essentials
Java Architect Essentials
Aug 31, 2024 · Backend Development

Java Backend Performance Optimization: Parallel Processing, Transaction Scope, Caching, Thread Pools, and Concurrency

This article provides a comprehensive guide to improving Java backend performance by explaining parallel processing with CompletableFuture, minimizing transaction scope, effective caching strategies, proper thread‑pool configuration, cache‑line alignment, reducing object creation, lock granularity, copy‑on‑write collections, asynchronous patterns, loop optimizations, network payload reduction, and minimizing inter‑service dependencies.

CachingJavaOptimization
0 likes · 33 min read
Java Backend Performance Optimization: Parallel Processing, Transaction Scope, Caching, Thread Pools, and Concurrency