BestHub
Sign in
Tagged articles

thread pool

241 articles · Page 2 of 3
Architecture Digest
Architecture Digest
Nov 10, 2023 · Backend Development

Understanding Spring Boot @Async: Usage, Pitfalls, and Best Practices

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.

AsynchronousSpring BootTransaction
0 likes · 10 min read
Understanding Spring Boot @Async: Usage, Pitfalls, and Best Practices
php Courses
php Courses
Nov 8, 2023 · Backend Development

Implementing Thread Pools and Coroutines in PHP

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.

PHPconcurrencycoroutine
0 likes · 5 min read
Implementing Thread Pools and Coroutines in PHP
IT Services Circle
IT Services Circle
Nov 7, 2023 · Backend Development

Understanding ThreadLocal Memory Leaks and How to Prevent Them

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.

Garbage CollectionJavaThreadLocal
0 likes · 11 min read
Understanding ThreadLocal Memory Leaks and How to Prevent Them
Huolala Tech
Huolala Tech
Oct 10, 2023 · Mobile Development

Optimizing Android Threads with Bytecode Instrumentation and Proxy Pools

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.

Androidbytecode instrumentationthread optimization
0 likes · 21 min read
Optimizing Android Threads with Bytecode Instrumentation and Proxy Pools
Shepherd Advanced Notes
Shepherd Advanced Notes
Sep 29, 2023 · Backend Development

How to Cut API Latency from 5 s to 0.5 s with CompletableFuture Async Optimizations

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.

CompletableFutureJava 8asynchronous programming
0 likes · 20 min read
How to Cut API Latency from 5 s to 0.5 s with CompletableFuture Async Optimizations
Top Architecture Tech Stack
Top Architecture Tech Stack
Sep 21, 2023 · Backend Development

Determining the Optimal Thread Pool Size Based on CPU Utilization

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.

Javacpu-utilizationperformance testing
0 likes · 12 min read
Determining the Optimal Thread Pool Size Based on CPU Utilization
Liangxu Linux
Liangxu Linux
Sep 17, 2023 · Backend Development

7 High‑Performance Server Event‑Handling Models: Reactor, Proactor and Beyond

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.

ProactorReactorbackend-architecture
0 likes · 21 min read
7 High‑Performance Server Event‑Handling Models: Reactor, Proactor and Beyond
FunTester
FunTester
Sep 10, 2023 · Backend Development

Mastering Java ShutdownHook: Clean Up Resources and Track Tasks Gracefully

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.

JVMJavaResource Management
0 likes · 8 min read
Mastering Java ShutdownHook: Clean Up Resources and Track Tasks Gracefully
政采云技术
政采云技术
Sep 6, 2023 · Fundamentals

Understanding Threads, Multithreading, and Virtual Threads in Java

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.

JDKJavaThreads
0 likes · 15 min read
Understanding Threads, Multithreading, and Virtual Threads in Java
Java Architect Essentials
Java Architect Essentials
Sep 6, 2023 · Backend Development

Understanding Spring Boot 2.7.10’s Embedded Tomcat: Defaults, Thread Pools, and Connection Limits

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.

Backend DevelopmentConnection ManagementEmbedded Server
0 likes · 15 min read
Understanding Spring Boot 2.7.10’s Embedded Tomcat: Defaults, Thread Pools, and Connection Limits
Zhuanzhuan Tech
Zhuanzhuan Tech
Jul 26, 2023 · Backend Development

Applying CompletableFuture for Asynchronous Programming in Java: A ZhiZhi Store Detail Page Case Study

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.

AsynchronousCompletableFutureJava
0 likes · 14 min read
Applying CompletableFuture for Asynchronous Programming in Java: A ZhiZhi Store Detail Page Case Study
Ctrip Technology
Ctrip Technology
Jun 1, 2023 · Backend Development

Optimizing Microservice Timeout Issues: Analysis and Practical Solutions

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.

Backend PerformanceCachingGC Tuning
0 likes · 21 min read
Optimizing Microservice Timeout Issues: Analysis and Practical Solutions
Code Ape Tech Column
Code Ape Tech Column
May 31, 2023 · Backend Development

Tomcat Performance Tuning Guide: Core Components and Key Parameters

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.

ConnectorJavaPerformance Tuning
0 likes · 11 min read
Tomcat Performance Tuning Guide: Core Components and Key Parameters
Architect
Architect
May 8, 2023 · Backend Development

Traceable Logging in Spring Boot: Using Logback, Interceptors, MDC and Custom Thread Pools

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.

AsynchronousLoggingMDC
0 likes · 12 min read
Traceable Logging in Spring Boot: Using Logback, Interceptors, MDC and Custom Thread Pools
Programmer DD
Programmer DD
Apr 7, 2023 · Backend Development

Why Thread Pools Outperform Direct Thread Creation in High‑Concurrency Java Applications

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.

Executorperformancethread pool
0 likes · 13 min read
Why Thread Pools Outperform Direct Thread Creation in High‑Concurrency Java Applications
360 Quality & Efficiency
360 Quality & Efficiency
Mar 31, 2023 · Backend Development

Understanding ThreadPoolExecutor: Key Parameters and Source Code Analysis

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.

ExecutorServiceJava concurrencyThreadPoolExecutor
0 likes · 17 min read
Understanding ThreadPoolExecutor: Key Parameters and Source Code Analysis
AI Cyberspace
AI Cyberspace
Mar 29, 2023 · Fundamentals

Mastering POSIX Threads: From User Threads to Thread Pools in Linux

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.

C ProgrammingLinuxmultithreading
0 likes · 21 min read
Mastering POSIX Threads: From User Threads to Thread Pools in Linux
MaGe Linux Operations
MaGe Linux Operations
Jan 25, 2023 · Backend Development

Root Causes of API Performance Bottlenecks and Practical Fixes

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.

API performanceCachingLock design
0 likes · 16 min read
Root Causes of API Performance Bottlenecks and Practical Fixes
Sohu Tech Products
Sohu Tech Products
Jan 11, 2023 · Backend Development

Understanding ThreadPoolExecutor in Java: Usage, Implementation Details, and Practical Scenarios

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.

DubboExecutorServiceSpring
0 likes · 34 min read
Understanding ThreadPoolExecutor in Java: Usage, Implementation Details, and Practical Scenarios
Code Ape Tech Column
Code Ape Tech Column
Dec 30, 2022 · Backend Development

Implementing a Dynamic Thread Pool with Nacos in Spring Boot

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.

Backend DevelopmentSpring Bootdynamic-configuration
0 likes · 9 min read
Implementing a Dynamic Thread Pool with Nacos in Spring Boot
ITPUB
ITPUB
Sep 20, 2022 · Backend Development

How to Boost High‑Concurrency Systems with Asynchronous Architecture Patterns

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.

Asynchronousthread pool
0 likes · 7 min read
How to Boost High‑Concurrency Systems with Asynchronous Architecture Patterns
Code Ape Tech Column
Code Ape Tech Column
Sep 8, 2022 · Backend Development

Tomcat Performance Tuning: Core Components and Key Parameters

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.

JavaPerformance TuningServer Configuration
0 likes · 11 min read
Tomcat Performance Tuning: Core Components and Key Parameters
dbaplus Community
dbaplus Community
Sep 6, 2022 · Backend Development

How to Scale High‑Concurrency Write Operations with Asynchronous Patterns

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.

AsynchronousBatch ProcessingHigh concurrency
0 likes · 8 min read
How to Scale High‑Concurrency Write Operations with Asynchronous Patterns
Java High-Performance Architecture
Java High-Performance Architecture
Aug 22, 2022 · Backend Development

Why Resource Isolation Matters: Thread, Process, and Cluster Strategies in Backend Systems

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.

Process isolationResource Isolationbackend
0 likes · 14 min read
Why Resource Isolation Matters: Thread, Process, and Cluster Strategies in Backend Systems
Su San Talks Tech
Su San Talks Tech
Aug 1, 2022 · Backend Development

Master Tomcat Performance: Key Components and Tuning Tips for Max Throughput

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.

ConnectorJavaPerformance Tuning
0 likes · 12 min read
Master Tomcat Performance: Key Components and Tuning Tips for Max Throughput
Java Architect Essentials
Java Architect Essentials
Jul 31, 2022 · Backend Development

Comprehensive Guide to Backend Interface Performance Optimization

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.

CachingOptimizationbackend
0 likes · 17 min read
Comprehensive Guide to Backend Interface Performance Optimization
Selected Java Interview Questions
Selected Java Interview Questions
Jul 19, 2022 · Backend Development

Comprehensive Guide to Identifying and Solving Backend Interface Performance Issues

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.

CachingOptimizationbackend
0 likes · 16 min read
Comprehensive Guide to Identifying and Solving Backend Interface Performance Issues
Architect's Tech Stack
Architect's Tech Stack
Jul 19, 2022 · Backend Development

Asynchronous Excel Import with Thread Pool and AOP in Java

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.

AOPJavaasynchronous processing
0 likes · 10 min read
Asynchronous Excel Import with Thread Pool and AOP in Java
Java Backend Technology
Java Backend Technology
Jul 19, 2022 · Backend Development

How to Diagnose and Fix Common API Performance Bottlenecks in Java Backend

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.

CachingOptimizationbackend
0 likes · 17 min read
How to Diagnose and Fix Common API Performance Bottlenecks in Java Backend
Tencent Cloud Developer
Tencent Cloud Developer
Jul 14, 2022 · Fundamentals

Implementation Details of Scheduler and Context in libunifex (CPU Thread Execution Context)

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.

C++Execution Contextasync
0 likes · 16 min read
Implementation Details of Scheduler and Context in libunifex (CPU Thread Execution Context)
Java Backend Technology
Java Backend Technology
Jul 12, 2022 · Backend Development

Boost Java Batch Updates with Multithreading: A Practical Guide

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.

Batch ProcessingJavabackend
0 likes · 7 min read
Boost Java Batch Updates with Multithreading: A Practical Guide
Yang Money Pot Technology Team
Yang Money Pot Technology Team
Jul 4, 2022 · Backend Development

Understanding Netty’s Multithreaded Reactor Model and Its Application in an Online Customer Service IM System

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.

Backend DevelopmentEventLoopJava
0 likes · 21 min read
Understanding Netty’s Multithreaded Reactor Model and Its Application in an Online Customer Service IM System
Sanyou's Java Diary
Sanyou's Java Diary
Jun 27, 2022 · Backend Development

How Eureka’s Heartbeat Keeps Microservices Alive: A Deep Dive

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.

Microserviceseurekaheartbeat
0 likes · 7 min read
How Eureka’s Heartbeat Keeps Microservices Alive: A Deep Dive
Top Architect
Top Architect
Jun 4, 2022 · Backend Development

Backend Performance Optimization: Common Issues, Root Causes, and Practical Solutions

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.

CachingOptimizationbackend
0 likes · 17 min read
Backend Performance Optimization: Common Issues, Root Causes, and Practical Solutions
HomeTech
HomeTech
Jun 1, 2022 · Backend Development

Design and Optimization of a Ride‑Hailing Platform: Unified Fleet Integration and Concurrent Price Estimation

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.

MicroservicesRide Hailingthread pool
0 likes · 15 min read
Design and Optimization of a Ride‑Hailing Platform: Unified Fleet Integration and Concurrent Price Estimation
Architect's Journey
Architect's Journey
Jun 1, 2022 · Operations

How We Resolved a Kafka Consumer Production Outage Step by Step

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.

JavaMessage QueueMicroservices
0 likes · 6 min read
How We Resolved a Kafka Consumer Production Outage Step by Step
IT Architects Alliance
IT Architects Alliance
May 30, 2022 · Backend Development

How to Diagnose and Fix API Performance Bottlenecks in Java Backend

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.

CachingJavaOptimization
0 likes · 17 min read
How to Diagnose and Fix API Performance Bottlenecks in Java Backend
Architect
Architect
May 29, 2022 · Backend Development

Comprehensive Summary of Interface Performance Issues and Optimization Strategies

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.

Optimizationthread pool
0 likes · 16 min read
Comprehensive Summary of Interface Performance Issues and Optimization Strategies
Cognitive Technology Team
Cognitive Technology Team
Apr 29, 2022 · Backend Development

Spring Cloud Managed Thread Pools Are Automatically Wrapped with Trace Information to Preserve Context

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.

JavaSpring BootTracing
0 likes · 6 min read
Spring Cloud Managed Thread Pools Are Automatically Wrapped with Trace Information to Preserve Context
High Availability Architecture
High Availability Architecture
Mar 24, 2022 · Backend Development

Understanding Go's Goroutine Scheduling: Design Principles, GMP Model, and Optimizations

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.

GMP modelGoGoroutine
0 likes · 14 min read
Understanding Go's Goroutine Scheduling: Design Principles, GMP Model, and Optimizations
IT Services Circle
IT Services Circle
Mar 15, 2022 · Backend Development

Understanding Pooling Techniques: Thread Pools, Memory Pools, Database Connection Pools, and HttpClient Pools in Java

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.

Connection PoolJavaResource Management
0 likes · 10 min read
Understanding Pooling Techniques: Thread Pools, Memory Pools, Database Connection Pools, and HttpClient Pools in Java
Architecture Digest
Architecture Digest
Feb 25, 2022 · Backend Development

A Comprehensive Summary of Our Backend Interface Performance Optimization Journey

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.

CachingOptimizationmysql
0 likes · 18 min read
A Comprehensive Summary of Our Backend Interface Performance Optimization Journey
Java Interview Crash Guide
Java Interview Crash Guide
Feb 17, 2022 · Backend Development

Boost Your Java Backend: Practical Coding Habits and Best Practices

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.

Javacode qualitythread pool
0 likes · 11 min read
Boost Your Java Backend: Practical Coding Habits and Best Practices
Aikesheng Open Source Community
Aikesheng Open Source Community
Jan 6, 2022 · Databases

Dynamic Adjustment of DBLE Thread Pools Without Restart

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.

DBLEDatabase MiddlewareDynamic Scaling
0 likes · 11 min read
Dynamic Adjustment of DBLE Thread Pools Without Restart
Programmer DD
Programmer DD
Dec 19, 2021 · Backend Development

Boost Java Performance 4× with CompletableFuture: When and How to Use It

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.

AsynchronousCompletableFutureJDK8
0 likes · 21 min read
Boost Java Performance 4× with CompletableFuture: When and How to Use It
vivo Internet Technology
vivo Internet Technology
Dec 16, 2021 · Fundamentals

In‑Depth Analysis of JDK ThreadPoolExecutor: Construction, Execution Flow, Worker Mechanics, Shutdown and Custom Extensions

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.

ExecutorServiceJava concurrencyShutdown
0 likes · 33 min read
In‑Depth Analysis of JDK ThreadPoolExecutor: Construction, Execution Flow, Worker Mechanics, Shutdown and Custom Extensions
Tencent Database Technology
Tencent Database Technology
Oct 20, 2021 · Databases

Percona Thread Pool Implementation and TXSQL Optimizations: Architecture, Dynamic Switching, Load Balancing, and Disconnection Handling

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.

Connection HandlingPerconaTXSQL
0 likes · 27 min read
Percona Thread Pool Implementation and TXSQL Optimizations: Architecture, Dynamic Switching, Load Balancing, and Disconnection Handling
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 16, 2021 · Backend Development

Ten Everyday Analogies to Explain Core Backend Interview Topics

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.

interviewrate limitingserialization
0 likes · 9 min read
Ten Everyday Analogies to Explain Core Backend Interview Topics
Top Architect
Top Architect
Oct 13, 2021 · Backend Development

Using ThreadPoolTaskExecutor for Asynchronous Operations in Spring Boot

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.

AsyncJavaSpring Boot
0 likes · 12 min read
Using ThreadPoolTaskExecutor for Asynchronous Operations in Spring Boot
Top Architect
Top Architect
Sep 18, 2021 · Backend Development

Resource Isolation Techniques in Distributed Systems: Thread, Process, Cluster, and More

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.

DubboHystrixNetty
0 likes · 13 min read
Resource Isolation Techniques in Distributed Systems: Thread, Process, Cluster, and More
Programmer DD
Programmer DD
Sep 18, 2021 · Backend Development

Isolating Spring @Async Thread Pools to Prevent Task Interference

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.

JavaSpring Bootasync
0 likes · 10 min read
Isolating Spring @Async Thread Pools to Prevent Task Interference
Programmer DD
Programmer DD
Sep 17, 2021 · Backend Development

Avoid Out‑of‑Memory Errors: Properly Configure Spring Boot Async Thread Pool

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.

AsyncJavaMemory Management
0 likes · 11 min read
Avoid Out‑of‑Memory Errors: Properly Configure Spring Boot Async Thread Pool
Java Interview Crash Guide
Java Interview Crash Guide
Sep 14, 2021 · Backend Development

Mastering Java ThreadPoolExecutor: Deep Dive into Creation, Parameters, and Execution Flow

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.

JavaThreadPoolExecutorthread pool
0 likes · 7 min read
Mastering Java ThreadPoolExecutor: Deep Dive into Creation, Parameters, and Execution Flow
Youzan Coder
Youzan Coder
Aug 19, 2021 · Mobile Development

Thread Pool Isolation and Monitoring Design for Mobile Applications

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.

MonitoringPollingRxJava
0 likes · 12 min read
Thread Pool Isolation and Monitoring Design for Mobile Applications
JavaEdge
JavaEdge
Aug 18, 2021 · Backend Development

Why Tomcat’s Thread Pool Works Differently from the JDK’s

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.

JDKJavathread pool
0 likes · 7 min read
Why Tomcat’s Thread Pool Works Differently from the JDK’s
Java Architect Essentials
Java Architect Essentials
Aug 2, 2021 · Backend Development

Java Garbage Collection, JVM Memory Model, Concurrency Locks, Thread Pools and Distributed Locking

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.

Distributed LockGarbage CollectionJVM
0 likes · 23 min read
Java Garbage Collection, JVM Memory Model, Concurrency Locks, Thread Pools and Distributed Locking
vivo Internet Technology
vivo Internet Technology
Jun 16, 2021 · Backend Development

Troubleshooting Dubbo Thread Pool Exhaustion: A Redis Performance Optimization Case Study

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.

Connection PoolDubboPerformance Optimization
0 likes · 13 min read
Troubleshooting Dubbo Thread Pool Exhaustion: A Redis Performance Optimization Case Study
Weekly Large Model Application
Weekly Large Model Application
Jun 16, 2021 · Fundamentals

Understanding libuv’s Design: A Deep Dive into Its Event Loop and Cross‑Platform Architecture

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.

Cross-PlatformNode.jsasynchronous I/O
0 likes · 9 min read
Understanding libuv’s Design: A Deep Dive into Its Event Loop and Cross‑Platform Architecture
Top Architect
Top Architect
Jun 3, 2021 · Backend Development

Understanding Java ThreadPoolExecutor: Creation, Parameters, and Execution Flow

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.

Backend DevelopmentExecutorServiceJava
0 likes · 7 min read
Understanding Java ThreadPoolExecutor: Creation, Parameters, and Execution Flow
Java Backend Technology
Java Backend Technology
May 29, 2021 · Backend Development

Avoid Hidden ThreadLocal Pitfalls: Memory Leaks, Context Loss in Thread Pools & Parallel Streams

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.

JavaParallel StreamThreadLocal
0 likes · 9 min read
Avoid Hidden ThreadLocal Pitfalls: Memory Leaks, Context Loss in Thread Pools & Parallel Streams
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 15, 2021 · Backend Development

Using ThreadLocal in Java: Scenarios, Thread‑Safety Problems, and Practical Solutions

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.

JavaThreadLocalconcurrency
0 likes · 20 min read
Using ThreadLocal in Java: Scenarios, Thread‑Safety Problems, and Practical Solutions
Youzan Coder
Youzan Coder
Apr 7, 2021 · Mobile Development

Design and Implementation of a Mobile App Performance Monitoring System

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.

APMMobile AppOptimization
0 likes · 11 min read
Design and Implementation of a Mobile App Performance Monitoring System
Python Programming Learning Circle
Python Programming Learning Circle
Apr 2, 2021 · Fundamentals

Effective Python Parallelism with Thread Pools and the map() Function

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.

Multiprocessingconcurrencymap
0 likes · 11 min read
Effective Python Parallelism with Thread Pools and the map() Function
NetEase Cloud Music Tech Team
NetEase Cloud Music Tech Team
Mar 31, 2021 · Backend Development

Unveiling libuv’s Linux Event Loop: epoll, Thread Pools, and Timers Explained

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.

LinuxSystems ProgrammingTimers
0 likes · 34 min read
Unveiling libuv’s Linux Event Loop: epoll, Thread Pools, and Timers Explained
Selected Java Interview Questions
Selected Java Interview Questions
Mar 20, 2021 · Backend Development

Interview Reflections: HTTP GET Issue, Rate‑Limiting, and ThreadPool Mechanics

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.

HTTPrate limitingthread pool
0 likes · 10 min read
Interview Reflections: HTTP GET Issue, Rate‑Limiting, and ThreadPool Mechanics
vivo Internet Technology
vivo Internet Technology
Jan 27, 2021 · Backend Development

TransmittableThreadLocal Practice: Solving Multi-Country Business Context Propagation in E-commerce

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.

AlibabaInheritableThreadLocalJava concurrency
0 likes · 16 min read
TransmittableThreadLocal Practice: Solving Multi-Country Business Context Propagation in E-commerce
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jan 9, 2021 · Big Data

Performance Optimization of Elasticsearch in an ELK Log Architecture

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.

ELKElasticsearchJVM
0 likes · 20 min read
Performance Optimization of Elasticsearch in an ELK Log Architecture
Programmer DD
Programmer DD
Nov 30, 2020 · Backend Development

How Many Threads Are Optimal? Mastering Thread Pool Sizing for Maximum Performance

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.

I/O BoundPerformance Optimizationconcurrency
0 likes · 4 min read
How Many Threads Are Optimal? Mastering Thread Pool Sizing for Maximum Performance
macrozheng
macrozheng
Nov 3, 2020 · Backend Development

Understanding Java Thread Pools Through a Story Analogy

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.

Core ThreadsJavablocking queue
0 likes · 9 min read
Understanding Java Thread Pools Through a Story Analogy
Architecture Digest
Architecture Digest
Oct 6, 2020 · Backend Development

Comparing BIO, NIO, and Asynchronous Models Using a Bank Process Analogy

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.

AsynchronousBIONIO
0 likes · 6 min read
Comparing BIO, NIO, and Asynchronous Models Using a Bank Process Analogy
360 Quality & Efficiency
360 Quality & Efficiency
Oct 1, 2020 · Backend Development

Advanced Python Logging: StreamHandler, FileHandler, HTTPHandler and Asynchronous Remote Logging with aiohttp and Thread Pools

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.

HttpHandlerLoggingPython
0 likes · 16 min read
Advanced Python Logging: StreamHandler, FileHandler, HTTPHandler and Asynchronous Remote Logging with aiohttp and Thread Pools
Programmer DD
Programmer DD
Sep 7, 2020 · Backend Development

Boost Server Throughput: From Blocking I/O to NIO and Asynchronous Models

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.

AsynchronousI/ONIO
0 likes · 6 min read
Boost Server Throughput: From Blocking I/O to NIO and Asynchronous Models
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Aug 2, 2020 · Backend Development

Understanding Pooling Techniques: Thread Pools, Memory Pools, Connection Pools, and HttpClient Pools in Java

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.

Connection PoolJavabackend
0 likes · 11 min read
Understanding Pooling Techniques: Thread Pools, Memory Pools, Connection Pools, and HttpClient Pools in Java
Programmer DD
Programmer DD
Jul 12, 2020 · Backend Development

How to Calculate the Optimal Thread Pool Size for Java Applications

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.

Javaconcurrencyperformance
0 likes · 5 min read
How to Calculate the Optimal Thread Pool Size for Java Applications
Java Captain
Java Captain
Jul 6, 2020 · Backend Development

Deep Dive into Java ThreadPoolExecutor: Implementation Principles and Source Code Analysis

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.

ExecutorServiceJavaThreadPoolExecutor
0 likes · 30 min read
Deep Dive into Java ThreadPoolExecutor: Implementation Principles and Source Code Analysis
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 29, 2020 · Backend Development

Dynamic Thread Pool Component with Cat Monitoring and Nacos Configuration for Spring Cloud

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.

Cat monitoringJava concurrencydynamic-configuration
0 likes · 13 min read
Dynamic Thread Pool Component with Cat Monitoring and Nacos Configuration for Spring Cloud
Selected Java Interview Questions
Selected Java Interview Questions
Jun 26, 2020 · Backend Development

Why Executors Should Not Be Used to Create Thread Pools and How to Properly Configure ThreadPoolExecutor in Java

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.

ExecutorsJavaOOM
0 likes · 13 min read
Why Executors Should Not Be Used to Create Thread Pools and How to Properly Configure ThreadPoolExecutor in Java
21CTO
21CTO
May 28, 2020 · Backend Development

Unlocking Java ThreadPoolExecutor: Design, Implementation, and Dynamic Tuning

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.

JavaThreadPoolExecutordynamic-configuration
0 likes · 29 min read
Unlocking Java ThreadPoolExecutor: Design, Implementation, and Dynamic Tuning
Laravel Tech Community
Laravel Tech Community
May 17, 2020 · Databases

Can MySQL Handle 100,000 Concurrent Connections? A Real‑World Test

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.

High concurrencySysbenchdatabase scaling
0 likes · 8 min read
Can MySQL Handle 100,000 Concurrent Connections? A Real‑World Test
58 Tech
58 Tech
May 8, 2020 · Backend Development

Optimizing High‑Concurrency List Service for 58 Used‑Car Platform: Data Query, Transformation, and Thread‑Pool Tuning

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.

High concurrencyJavaconcurrency
0 likes · 9 min read
Optimizing High‑Concurrency List Service for 58 Used‑Car Platform: Data Query, Transformation, and Thread‑Pool Tuning