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.
This article demonstrates how to configure Python's logging module for console and file output, extend it with HTTPHandler for remote logging, and improve performance by using custom handlers, threading, thread pools, and asynchronous aiohttp calls to avoid blocking the main program.
This article uses a bank workflow analogy to compare blocking I/O (BIO), non‑blocking I/O (NIO), and asynchronous processing, showing how task decomposition and specialized threads dramatically increase system throughput while illustrating the trade‑offs of each approach.
This article explains the concept of pooling—pre‑creating reusable resources—and demonstrates how thread pools, memory pools, database connection pools, and HttpClient pools improve Java application performance, backed by code examples and benchmark results.
This article explains the concept of pooling technology in Java, illustrating its benefits through real‑world analogies, detailing thread pools, memory pools, database connection pools, and HttpClient pools, and provides a performance comparison between raw threads and thread pools using a Java benchmark.
This article compares two popular formulas for estimating Java thread pool size, analyzes their equivalence, and provides practical guidelines for configuring thread counts in I/O‑bound and CPU‑bound workloads, including code examples and performance considerations.
This article explains why thread pools are essential for Java applications, details the seven key parameters of ThreadPoolExecutor, describes the possible thread‑pool states, and walks through the core methods such as execute, addWorker, runWorker and getTask with code examples.
This article provides a comprehensive analysis of Java's ThreadPoolExecutor, explaining its purpose, core attributes, state management using the ctl field, constructors, task submission mechanisms, worker thread creation, execution flow, task retrieval, shutdown procedures, and the intricate synchronization techniques that enable efficient thread reuse.
This article introduces a dynamic thread‑pool component for Spring Cloud that supports Cat monitoring, runtime core‑parameter adjustments, queue‑capacity and reject‑count alerts, and provides Nacos‑based configuration, code examples, and endpoint integration for operational visibility.
This article explains the definition of thread pools, why using Executors to create them is discouraged, details the ThreadPoolExecutor constructor and its parameters, compares different Executors factory methods, demonstrates OOM testing, and provides practical guidelines for defining safe thread‑pool parameters in Java.
This article explains the concept and benefits of Java thread pools, dives deep into the internal design and lifecycle of ThreadPoolExecutor with code examples, discusses real‑world usage scenarios and common configuration pitfalls, and presents a dynamic, monitorable thread‑pool solution to improve performance and reliability.
This article details a comprehensive experiment that evaluates MySQL's ability to sustain up to 100,000 simultaneous connections using Percona Server's thread‑pool plugin, sysbench clients, adjusted OS/network limits, and multiple IP addresses, presenting hardware specs, configuration steps, observed errors, performance metrics, and practical recommendations.
This article analyzes the performance bottlenecks of the 58 used‑car list service under high concurrency, breaks down data‑query and data‑transfer stages, and presents three optimization solutions—including query redesign, concurrent data conversion, and thread‑pool parameter tuning—that together reduce latency by over 80 ms and improve resource utilization.
This article explains the concept, design, and internal implementation of Java's ThreadPoolExecutor, discusses common thread‑pool problems, presents dynamic configuration solutions, and provides practical usage scenarios and code examples to help developers efficiently manage concurrency in backend applications.
This article provides a comprehensive analysis of Java's ThreadPoolExecutor source code, explaining its design, core attributes, constructors, task submission mechanisms, worker thread creation, thread‑reuse logic, and shutdown procedures, while illustrating each concept with detailed code examples and diagrams.
This article explains why multithreading remains essential, distinguishes CPU‑bound and I/O‑bound scenarios, provides formulas for calculating the optimal number of threads, discusses interview questions, and highlights practical considerations such as thread pools and synchronization.
This article explains the purpose, benefits, core APIs, implementation classes, execution flow, state management, and monitoring methods of Java thread pools, providing detailed code examples and diagrams to help developers understand and effectively use thread pooling in high‑concurrency applications.
This article details recent updates to a performance testing framework, including moving the mark feature into ThreadBase, changing method signatures, introducing two virtual thread limit classes for count‑based and time‑based execution, optimizing after() handling, and abandoning deep‑copy cloning for thread objects.
This article summarizes the Tongtian Tower backend performance optimization experience, detailing background, achieved improvements of 10‑30%, optimization principles, testing methods, metric analysis, and concrete strategies such as RPC scheduling, JVM tuning, logging, thread‑pool and code refinements to enhance latency and throughput.
This comprehensive guide explains Java thread pool fundamentals, creation methods, core parameters, rejection policies, execution flow, common work queues, and shutdown techniques, while providing interview questions, source‑code analysis, and practical code examples for robust concurrent programming.
This article examines the JD.com product detail page backend architecture, analyzes memory, thread, and CPU usage, and outlines a three‑stage optimization roadmap—including parallelization, JVM/Tomcat upgrades, thread‑pool tuning, and asynchronous refactoring—to handle massive traffic spikes.
This article explains the definition of Java thread pools, why creating them via Executors is discouraged, details the ThreadPoolExecutor constructor and parameters, compares different Executors factory methods, demonstrates OOM risks with tests, and offers guidelines for configuring thread pool size and rejection policies.
The article explains why creating and destroying threads directly is inefficient and risky for high‑traffic services, then introduces thread pools as a solution, detailing four common pool types with code examples, their advantages, limitations, and overall impact on system performance.
