This article explains what a thread pool is—a collection of pre‑instantiated idle threads that execute tasks efficiently—and outlines the essential steps to implement one, including thread creation, container management, and task interface design.
This article walks through the design and implementation of a three‑tier instant‑messaging platform—including a Netty‑based chat server, a JavaFX client, and a SpringBoot web admin console—covering architecture, protocol design, database schema, key Netty handlers, threading, and authentication details.
This article explains how to configure Spring Boot's built‑in ThreadPoolTaskExecutor, customize its core parameters, and use it together with Java 8 CompletableFuture to run asynchronous tasks, including a performance comparison with a synchronous implementation.
This article demonstrates how to create a dynamically configurable thread pool in a Spring Boot backend by using Nacos as a configuration center, covering Maven dependencies, YAML configuration files, Nacos data IDs, Java implementation with listeners, a REST controller for testing, and practical verification steps.
This article explains the differences between CPU‑intensive and I/O‑intensive workloads, provides optimization strategies such as multithreading, caching, and load balancing, and presents Java code examples and formulas for calculating the optimal thread‑pool size based on core count, target CPU utilization, and blocking factors.
Version 8.3 of MySQL introduces tagged GTID replication, a selectable JSON EXPLAIN format version, enhanced thread‑pool plugin information, changes to binlog transaction dependency tracking and new CMake options, while removing several C API functions, the FLUSH HOSTS statement, and outdated replication flags.
This article documents the investigation of a JSF asynchronous call timeout that reduced interface availability, explains the async call mechanisms, analyzes the root cause in the callback thread pool, and presents short‑term and long‑term solutions to restore 100% availability.
The article details a step‑by‑step investigation of a Spring Boot service that failed to meet a 500 requests/second target, analyzes slow SQL, thread‑pool misconfiguration, excessive logging, and high CPU usage, and presents concrete optimizations that roughly doubled throughput.
This article explains the default Tomcat settings in Spring Boot 2.7.10, detailing connection queues, thread pool parameters, timeout configurations, and internal threading architecture, and provides practical examples and testing results for various concurrent connection scenarios.
This guide explains why thread pools are essential in Java, walks through factors such as CPU cores, I/O latency, and workload characteristics, and provides formulas and concrete code examples for calculating the ideal pool size for both CPU‑bound and I/O‑bound tasks.
This article explains the three JVM termination modes, how to use shutdown hooks and Spring's lifecycle events to implement graceful shutdown of HTTP, RPC and MQ entry points, manage thread‑pool termination, and avoid resource‑leak or inconsistent state during service redeployment.
A ToB system that seemed able to handle 500 requests per second stalled at 50 req/s due to hidden lock contention in prototype‑scoped Spring beans, slow SQL updates, excessive logging, and thread‑pool misconfiguration, prompting a step‑by‑step performance investigation and multiple optimizations.
This article explains how to enable and configure Spring Boot's @Async annotation, demonstrates proper thread‑pool setup, highlights common mistakes such as calling async methods within the same class or mixing with @Transactional, and provides guidance on handling blocking tasks and exceptions for robust asynchronous execution.
This article explains how to implement low‑level thread pools and coroutine mechanisms in PHP, providing detailed code examples that demonstrate creating a ThreadPool class, managing worker threads, and using generator‑based coroutines to achieve high‑performance, concurrent execution.
The article details a step‑by‑step performance investigation and optimization of a Spring‑based ToB system, covering slow SQL, thread‑pool tuning, JVM memory adjustments, excessive logging, and bean‑creation overhead, ultimately improving throughput from 50 req/s to nearly the required 500 req/s.
This article explains the internal structure of ThreadLocal, identifies scenarios where ThreadLocal can cause memory leaks—especially in thread‑pool environments—analyzes the root causes, and provides practical techniques such as using remove() and expungeStaleEntry() to avoid these leaks.
A Java ToB system struggled to meet a 500 requests‑per‑second target, revealing hidden bottlenecks such as slow SQL, excessive logging, thread‑pool misconfiguration, high CPU usage from Spring bean creation, and improper Redis usage, which were systematically identified and mitigated.
This article explains Java threads and thread pools, covering basic concepts, creation methods, execution differences, multithreading benefits, detailed analysis of ThreadPoolExecutor internals, and practical usage examples with code snippets.
This article presents a comprehensive approach to reducing thread overhead in Android applications by detecting, counting, and consolidating thread creation through bytecode instrumentation, proxy thread pools, and stack size trimming, ultimately improving memory usage, CPU load, and UI smoothness.
The article explains how to dramatically reduce the response time of an API that must call multiple downstream services by converting serial calls into parallel ones using Java 8's CompletableFuture, covering its relationship to Future, core APIs, task composition, exception handling, and practical best‑practice recommendations.
This article explains how to size a thread pool by understanding CPU core limits, I/O wait effects, empirical testing on a multi‑core machine, and a practical formula, while emphasizing that real‑world workloads require iterative performance testing to find the best thread count.
This article explains the fundamentals of Reactor and Proactor event‑handling patterns, discusses Linux’s limited AIO support, and presents seven practical server concurrency models—from single‑threaded accept to multi‑process thread‑pool designs—detailing their workflows, advantages, drawbacks, and suitable use cases.
This article explains how a CPU fetches and executes instructions, how processes and threads are created and managed, and why thread pools are crucial for efficiently handling short‑lived tasks on modern multi‑core systems.
This article explains how to build a high‑performance Go server capable of processing up to one million requests per minute using efficient goroutine‑pool patterns, detailing the design of two worker structures, their dispatch, start, stop mechanisms, and practical optimizations.
This article demonstrates practical ways to leverage Java's ShutdownHook API for task statistics, connection cleanup, handling JVM abnormal exits, and persisting state during performance testing, providing code examples, pitfalls of daemon threads, and strategies for reliable resource management in backend applications.
This article explains the concept of threads in computer science, demonstrates how Java encapsulates threads with the Thread class, shows basic and multithreaded examples, introduces thread pools and their management, and details the new virtual thread model introduced by Project Loom for high‑throughput, low‑overhead concurrency.
This article examines Spring Boot 2.7.10’s embedded Tomcat configuration, detailing default connection queue sizes, thread pool parameters, key Tomcat settings such as AcceptCount and MaxConnections, internal thread components, and practical testing results that reveal how connection limits affect client‑server handshakes.
This article explains how Spring 5.3’s @Scheduled and @Async annotations are processed, detailing the bean lookup sequence for TaskScheduler and AsyncConfigurer, the default thread pool creation mechanisms, and the configuration of web asynchronous support, with code examples for each step.
This article explains the limitations of Java Future, introduces CompletableFuture's asynchronous and compositional capabilities, and demonstrates how to refactor a store detail page service using CompletableFuture, custom thread pools, and design patterns to achieve parallel execution, reduced latency, and better code maintainability.
This article examines common timeout problems in microservice architectures, identifies root causes such as connection and socket timeouts, and presents ten practical optimization techniques—including setting appropriate timeouts, rate limiting, cache improvements, thread‑pool tuning, GC and JIT adjustments, NIO async programming, host migration, and network checks—to enhance system stability and performance.
This article explains Tomcat's component architecture, describes the three critical parameters (maxThreads, maxConnections, acceptCount) that affect request handling, and provides practical tuning recommendations to improve backend performance without additional hardware costs.
This article demonstrates how to implement end‑to‑end traceable logging in a Spring Boot application by configuring Logback, creating a request interceptor that injects a TRACE_ID, propagating the ID across thread pools with custom executors and MDC utilities, and verifying the solution with sample controller code and log output.
In high‑concurrency Java scenarios, using a thread pool instead of creating raw Thread objects dramatically reduces resource consumption, prevents CPU overload and memory leaks, and offers reusable threads, controlled concurrency, task scheduling, and configurable rejection policies, all managed by the core ThreadPoolExecutor class.
This article explains the purpose of using thread pools in Java projects, details each important parameter of ThreadPoolExecutor, and provides a thorough walkthrough of its core source code, including constructors, task submission, execution, shutdown mechanisms, and internal worker management, helping developers understand and debug thread pool behavior.
This article explains the concepts of user threads, the pthread library implementation, thread creation and termination functions, synchronization mechanisms like mutexes and condition variables, and demonstrates how to design and use a lightweight C thread‑pool with practical code examples.
The article enumerates common reasons why APIs become slow—ranging from database slow queries and complex business logic to poorly designed thread pools, locks, and machine issues—and offers concrete mitigation strategies such as query optimization, caching, asynchronous processing, and proper resource configuration.
This article provides an in‑depth overview of Java's ThreadPoolExecutor, covering why thread pools are needed, various creation methods via Executors, core parameters, internal workflow, source‑code analysis, monitoring, shutdown procedures, and real‑world applications such as Spring @Async and Dubbo integration.
This article demonstrates how to create a dynamically configurable thread pool in a Spring Boot backend by leveraging Nacos as a configuration center, covering dependency setup, YAML configuration, Java implementation with @RefreshScope, runtime parameter updates, and a simple controller for testing.
This article examines a high‑traffic video‑watching scenario, explains why synchronous database writes become a bottleneck, and presents four practical asynchronous solutions—thread‑pool, local memory with scheduled tasks, message‑queue, and Agent‑plus‑MQ—detailing their implementation steps, advantages, and trade‑offs.
The article explains how to achieve million‑level concurrency in Java by focusing on three fundamental problems—task division, synchronization, and mutual exclusion—using real‑world analogies, diagrams, and concrete code examples to illustrate proper multithreaded design.
This article explains Tomcat's component architecture, describes the request‑processing flow, and provides practical guidance on tuning the three critical parameters—maxThreads, maxConnections, and acceptCount—along with additional settings to improve backend service performance without additional hardware.
This article examines a high‑traffic video‑watching scenario, identifies database write bottlenecks, and presents four asynchronous solutions—thread‑pool, in‑memory queue with scheduled tasks, message‑queue, and Agent‑plus‑MQ—detailing their implementation steps, trade‑offs, and best‑practice guidelines.
This article explains how isolating resources such as CPU, network, and disk through thread, process, cluster, and other techniques improves utilization, prevents cascading failures, and enhances stability in distributed backend architectures, illustrated with Netty, Dubbo, Tomcat, and Hystrix examples.
This article explains how to handle time‑consuming Excel uploads by using a template‑method design, wrapping the process with an AOP aspect, and executing the actual upload asynchronously in a thread pool, while recording logs and error details for later inspection.
This article explains Tomcat’s internal component architecture, walks through the request‑processing flow, and details three crucial configuration parameters—maxThreads, maxConnections, and acceptCount—offering practical formulas and tuning guidelines to improve throughput without adding hardware.
This article summarizes the author's experience optimizing backend interface performance, covering common causes such as slow MySQL queries, complex business logic, thread‑pool and lock design flaws, and offers practical solutions including pagination tricks, indexing, caching, multithreading, and asynchronous callbacks.
This article explains common concurrency models, thread‑pool and coroutine techniques, and various Linux I/O models—including blocking, non‑blocking, multiplexing, and asynchronous I/O—highlighting their trade‑offs and practical usage in high‑performance backend systems.
Using thread pools in Java reduces resource consumption, speeds up response, and enhances system stability, while the optimal thread count depends on task type—IO‑bound tasks use roughly twice the CPU cores, CPU‑bound tasks match the core count, and mixed workloads follow a calculated formula.
This article recounts a backend team's experience of addressing numerous slow API endpoints, detailing root causes such as MySQL slow queries, complex business logic, thread‑pool and lock misconfigurations, and offers practical solutions including pagination fixes, indexing, query refactoring, concurrency improvements, and caching strategies.
This article explains how to handle large Excel uploads in Java by offloading parsing and validation to a thread pool, using the Template Method pattern to reduce boilerplate, and finally applying a custom AOP annotation to manage logging, error handling, and asynchronous execution in a clean, reusable way.
This article walks through real‑world API performance complaints, identifies root causes such as slow MySQL queries, thread‑pool misconfiguration, lock contention and machine issues, and presents practical solutions ranging from pagination rewrites and index tuning to multithreading, caching and async callbacks.
The article explains libunifex’s CPU‑thread scheduler architecture, detailing how a lightweight scheduler wraps a manual_event_loop execution context with a mutex‑protected FIFO task queue, how operations bridge receivers to the context, and outlines various thread‑bound and platform‑specific scheduler variants.
This article explains how to efficiently handle large‑scale batch updates in Java by splitting the data set, using a thread pool for concurrent processing, and providing reusable utility code, all illustrated with a clear workflow diagram and step‑by‑step examples.
This article explains Netty’s multithreaded Reactor architecture, introduces the underlying concepts such as Channel, ChannelPipeline, and EventLoop, shows how threads are allocated to ChannelHandlers, and demonstrates how to customize thread pools for customer‑service and agent‑side logic in an IM system.
This article explores how Eureka’s heartbeat mechanism works in microservice architectures, comparing it to the Tang dynasty tribute system, and details who sends the heartbeat, its interval, the sending process, server handling, and the actions performed after receipt, with code examples and thread‑pool configuration.
This article critiques heavyweight Python threading tutorials, explains why the built‑in map function combined with multiprocessing or multiprocessing.dummy offers a concise, efficient way to parallelize I/O‑ and CPU‑bound tasks, and demonstrates dramatic speed‑ups with real code examples.
This article presents a comprehensive summary of backend performance problems encountered in a production system—including slow queries, deep pagination, missing or ineffective indexes, excessive joins, large data volumes, thread‑pool and lock mis‑designs, machine issues, and caching strategies—along with concrete diagnostic steps and code‑level remedies to improve response times and stability.
This article explains the origin and system design of a ride‑hailing platform, compares direct and aggregation models, defines coverage and performance requirements, and details a unified fleet onboarding process together with a thread‑pool based concurrent price‑estimation solution that uses caching, priority grouping, and circuit‑breaker protection to achieve scalable, reliable service.
The article recounts a production incident where a Kafka‑based consumer in a finance microservice hit thread‑pool exhaustion and slow‑query alerts, analyzes the root causes of async processing and bulk message bursts, and outlines a three‑phase remediation that includes data repair, switching to synchronous consumption, and request‑level batching to prevent future failures.
This article walks through the background of a production Java service that received many performance complaints, enumerates common causes such as slow MySQL queries, complex business logic, thread‑pool misconfiguration, lock contention and machine issues, and provides concrete diagnostic steps and code‑level solutions including pagination fixes, indexing strategies, async processing, thread‑pool tuning, lock refinement and caching techniques.
This article reviews the author's experience with growing interface latency, analyzes common causes such as slow MySQL queries, complex business logic, thread‑pool and lock design flaws, and presents a range of practical optimization techniques including pagination fixes, indexing, concurrency improvements, caching and asynchronous callbacks.
This article walks through the design, core data structures, and complete lifecycle of Workflow’s compact yet fully‑featured C thread‑pool (thrdpool), explaining its API, synchronization mechanisms, graceful shutdown strategy, and how tasks can be scheduled or even destroy the pool from within.
This article explains how Spring Cloud automatically wraps container‑managed thread pool beans with tracing proxies to preserve distributed‑trace information, details the ExecutorBeanPostProcessor implementation, shows the relevant code for detecting and instrumenting executors, and notes when manual wrapping is required.
The article reviews Dmitry Vyukov's 2019 talk on Go's goroutine scheduler, explains the GMP (goroutine‑M‑Processor) model, walks through its evolution from naive thread‑per‑goroutine to thread pools and work‑stealing, and discusses fairness, pre‑emptive scheduling, and possible future improvements.
This article explains the concept of pooling technology, its advantages, and its practical applications in Java—including thread pools, memory pools, database connection pools, and HttpClient connection pools—while highlighting how these techniques improve performance, resource utilization, and system stability.
This article recounts the author's experience of identifying and solving various backend interface performance bottlenecks—including slow MySQL queries, complex business logic, thread‑pool and lock design flaws, and machine issues—by applying targeted optimizations such as pagination redesign, indexing, concurrency, and caching.
This article explains the differences between kill -9 and kill -15 signals for Spring Boot, demonstrates how to use shutdown hooks, the Actuator endpoint, and proper thread‑pool termination to achieve an orderly application shutdown without data loss or resource leaks.
This article shares a collection of practical Java backend coding habits—from using @ConfigurationProperties and @RequiredArgsConstructor, to modularizing code, handling exceptions, minimizing database queries, managing thread pools, naming caches, applying design patterns, and leveraging asynchronous tasks—to improve code quality and performance.
This article explains how DBLE version 3.21.06.* enables runtime, non‑restart adjustments of various thread‑pool parameters such as processors and backendProcessors, describes the underlying reactor and JDK thread‑pool mechanisms, and provides practical guidance and precautions for safely scaling thread pools in production environments.
This article explains how to replace synchronous price‑lookup APIs with Java 8's CompletableFuture, compares synchronous and asynchronous performance, introduces the most useful CompletableFuture creation and composition methods, shows practical code examples, and discusses when to prefer it over traditional Future or thread‑pool approaches.
The article thoroughly dissects Java’s ThreadPoolExecutor, explaining its constructor parameters, the ctl‑based state machine that governs thread creation, task queuing, worker locking, shutdown sequences, built‑in rejection policies, and demonstrates a real‑world extension via Vivo’s NexTask framework for high‑performance backend processing.
This article explains the background, principles, architecture, and detailed implementation of Percona's thread pool, and describes TXSQL's dynamic thread‑pool activation, load‑balancing strategies, disconnection optimizations, related configuration parameters, status variables, and a concise summary.
The article uses vivid real‑life analogies to clarify ten essential backend interview concepts—including HTTP statelessness, serialization, rate limiting, TCP handshakes, thread‑pool mechanics, flow‑control windows, BIO/NIO/AIO, deadlocks, and select versus epoll—helping readers grasp complex ideas through familiar scenarios.
This article explains how to configure and use Spring Boot's ThreadPoolTaskExecutor for asynchronous service methods, shows the required @Configuration and @EnableAsync annotations, demonstrates custom thread‑pool monitoring by extending ThreadPoolTaskExecutor, and provides complete code snippets and log examples.
This article explains theoretical formulas and practical guidelines for calculating the optimal thread pool size in Java, covering CPU‑bound and I/O‑bound workloads, how to measure CPU cores and blocking ratios, and provides example calculations and code snippets.
The article explains why resource isolation is essential in distributed architectures and details various isolation strategies—including thread, process, cluster, data read/write, static, and crawler isolation—illustrated with Netty, Dubbo, Tomcat examples, code snippets, and a comparison of thread‑pool versus semaphore isolation in Hystrix.
This tutorial explains why the default shared thread pool for @Async tasks can cause unrelated services to block each other, and shows step‑by‑step how to configure separate thread pools for different async tasks in Spring Boot, complete with code examples and a unit test.
This article explains why using @Async in Spring Boot can cause memory overflow when many requests trigger parallel tasks, examines the default thread‑pool settings that lead to unbounded queues, and provides step‑by‑step configuration of a safe thread pool to prevent out‑of‑memory failures.
This article explains why multithreading is essential for modern CPUs, introduces Java’s ThreadPoolExecutor and its parameters, discusses why using Executors is discouraged, and walks through the pool’s creation, task submission, worker lifecycle, and core methods with illustrative code snippets and diagrams.
The design separates the original I/O pool into dedicated network, I/O, and polling thread pools, adds comprehensive monitoring of task duration and frequency, enforces unified polling rules, and automatically tunes pool parameters, resulting in a 76 % reduction in UI lag and easier troubleshooting.
This article explains how Tomcat customizes Java’s ThreadPoolExecutor for I/O‑intensive web workloads, detailing the key parameters, the custom task queue and thread factory, the overridden execute logic, and the role of the submittedCount variable in preventing thread starvation under high concurrency.
This article explains cache consistency problems and solutions such as double‑delete and retry mechanisms, dives into Java fundamentals like HashMap internals and thread pools, and presents several backend interview coding questions with examples and code snippets.
The article provides a comprehensive overview of Java garbage‑collection algorithms, JVM memory regions, object reachability analysis, the semantics of volatile, synchronized and ReentrantLock, thread‑pool creation and operation, deadlock examples, distributed‑lock strategies, and related tooling such as JUC utilities and Git conflict handling.
The article examines why libuv handles file operations with a thread pool rather than true asynchronous disk I/O, outlining the engineering challenges of async disk APIs, the advantages of a blocking‑call thread pool, and details of libuv’s thread‑pool configuration and performance implications.
The case study details how a high‑traffic Dubbo service handling 1.8 billion daily requests suffered periodic circuit‑breaks due to thread‑pool exhaustion, traced to a cache‑bypass bug, Redis setex spikes, and an improperly warmed commons‑pool2 connection pool, and resolved by fixing the bug, scaling Redis, and tuning or downgrading the pool configuration to enable pre‑warming via minEvictableIdleTimeMillis.
libuv is a cross‑platform asynchronous I/O library originally built for Node.js that abstracts event‑driven I/O via handles and requests, provides a single‑threaded event loop with platform‑specific poll mechanisms, and uses a global thread pool for file and DNS operations, all while maintaining a consistent execution model.
This article explains why multithreading and thread pools are essential for modern server-side Java development, details the full set of ThreadPoolExecutor constructor parameters, and walks through the executor, addWorker, Worker, runWorker, and getTask implementations using JDK 1.8 source code examples.
This article explains three common ThreadLocal misuse traps—memory leaks caused by weak‑referenced keys, loss of thread‑local context in thread‑pool workers, and context disappearance in parallel streams—provides detailed code examples, and offers practical guidelines to prevent them in Java backend applications.
This article explains why ThreadLocal is both simple and tricky to use, demonstrates common pitfalls when formatting dates with SimpleDateFormat in multithreaded environments, analyzes thread‑safety issues, and provides practical solutions using synchronized blocks, ThreadLocal, and its advanced initialization methods for clean and efficient concurrent code.
The article describes a two‑part mobile app performance monitoring system that automatically instruments code to capture method execution times, ANR and frame stalls, then processes, cleans, aggregates, and visualizes the data on a backend platform to generate alerts, trend reports, and guide optimization across versions.
This article critiques traditional Python threading tutorials and demonstrates how to replace verbose thread‑pool code with concise map‑based parallelism using multiprocessing and multiprocessing.dummy, providing practical examples, performance measurements, and guidelines for choosing pool sizes for I/O‑ and CPU‑bound tasks.
This article provides a deep technical walkthrough of libuv’s Linux implementation, covering epoll‑based I/O handling, level‑ and edge‑triggered events, the event‑loop architecture, timer management with a min‑heap, thread‑pool integration, and the mechanisms that drive asynchronous callbacks in Node.js.
This article explains the pitfalls of creating Java thread pools with Executors, details how to correctly build them using ThreadPoolExecutor, clarifies core parameters, queue strategies, and rejection policies, and provides runnable code examples to illustrate proper usage.
The article shares three interview scenarios—a puzzling HTTP GET failure, a rate‑limiting challenge solved with token‑bucket logic, and a deep dive into Java ThreadPoolExecutor behavior—each followed by personal insights on problem‑solving, algorithm application, and understanding underlying principles.
The article explains how to reliably propagate country‑specific context across request handling, database access, and asynchronous thread pools in multi‑country e‑commerce by replacing simple ThreadLocal and InheritableThreadLocal with Alibaba’s TransmittableThreadLocal, demonstrating its integration with Spring MVC/Boot, MyBatis, Dubbo, and custom executors for both sharded and non‑sharded databases.
This article details a step‑by‑step performance tuning journey for a Java‑based SOA service, covering thread‑pool redesign, memory‑allocation adjustments, and JIT compilation tweaks that together lifted QPM by nearly 40% and overall system throughput by about 50%.
This article summarizes a year‑long performance tuning of an ELK logging system, analyzing bottlenecks such as write thread pool saturation, JVM heap and GC settings, refresh intervals, translog durability, merge threads, shard and replica counts, and provides concrete configuration changes that reduced latency, eliminated data loss, and stabilized node resource usage.
This article explains why multithreading improves program performance, distinguishes latency reduction from throughput increase, and provides practical formulas to determine the ideal number of threads for both I/O‑bound and CPU‑bound workloads, helping you fully utilize hardware resources.
This article uses a vivid workplace story to explain thread pools, covering core threads, blocking queues, non‑core threads, idle keep‑alive time, and saturation policies, and includes a workflow diagram and Java source snippet for clear comprehension.
The article uses a simple bank workflow with ten staff members to illustrate the differences in throughput between BIO (blocking I/O), NIO (non‑blocking I/O), and asynchronous processing, showing how task decomposition and specialized threads dramatically improve performance in backend systems.
