Skip to content
Tagged articles

thread pool

268 articles · Page 1 of 3
Raymond Ops
Raymond Ops
Nov 15, 2026 · Operations

Who Crashed First? Troubleshooting 502 Errors Across Nginx, Thread Pools & DB Connection Pools

This comprehensive guide walks through a systematic troubleshooting process for 502 Bad Gateway errors, detailing how to investigate Nginx upstream failures, application thread pool exhaustion, database connection pool saturation, slow queries, lock contention, and system resource bottlenecks with concrete commands and configuration examples.

502 troubleshootingConnection Poolincident response
0 likes · 47 min read
Who Crashed First? Troubleshooting 502 Errors Across Nginx, Thread Pools & DB Connection Pools
Mingyi World Elasticsearch
Mingyi World Elasticsearch
Nov 12, 2026 · Databases

Green Cluster ≠ Fast Cluster: A Production Troubleshooting & Tuning Framework for Easysearch

This article explains why an Easysearch cluster's green health status doesn't guarantee performance, and provides a comprehensive framework for production troubleshooting covering shard sizing, JVM tuning, thread pools, query optimization, monitoring dimensions, and a step-by-step diagnostic workflow.

EasysearchElasticsearchJVM tuning
0 likes · 17 min read
Green Cluster ≠ Fast Cluster: A Production Troubleshooting & Tuning Framework for Easysearch
Architecture Pony
Architecture Pony
Nov 2, 2026 · Backend Development

Spring Boot Scheduled Tasks: @Scheduled Internals to Distributed Scheduling Evolution

This article explores Spring Boot scheduled task evolution from @Scheduled basics through thread pool configuration, source code analysis of scheduling internals, distributed locking with ShedLock, and migration to XXL-JOB for sharding and high availability, including common pitfalls and a reconciliation system case study.

@ScheduledDistributed SchedulingShedLock
0 likes · 21 min read
Spring Boot Scheduled Tasks: @Scheduled Internals to Distributed Scheduling Evolution
Java Tech Workshop
Java Tech Workshop
Oct 26, 2026 · Backend Development

Spring Boot Graceful Shutdown: SIGTERM to Container Exit, Request Draining & Kubernetes Timing

This article dissects Spring Boot's graceful shutdown process, explaining how SIGTERM triggers request draining, the interplay between server.shutdown modes, Lifecycle phases, thread pool behavior, SmartLifecycle ordering, and Kubernetes terminationGracePeriodSeconds, with reproducible experiments showing how misconfigured timeouts cause deployment errors.

KubernetesRequest DrainingSIGTERM
0 likes · 17 min read
Spring Boot Graceful Shutdown: SIGTERM to Container Exit, Request Draining & Kubernetes Timing
Java Tech Workshop
Java Tech Workshop
Oct 20, 2026 · Backend Development

Why Thread Pools Leak User Data: ThreadLocal Internals and Solutions

This article explains how a static ThreadLocal without cleanup in a thread pool causes user data leakage and memory leaks, details ThreadLocalMap's weak-reference Entry structure, demonstrates InheritableThreadLocal's failure with pooled threads, and presents solutions including try-finally cleanup, interceptor-based clearing, Alibaba's TransmittableThreadLocal, and an AutoCloseable wrapper for safe scoping.

AutoCloseableInheritableThreadLocalJava Concurrency
0 likes · 10 min read
Why Thread Pools Leak User Data: ThreadLocal Internals and Solutions
SpringMeng
SpringMeng
Oct 18, 2026 · Interview Experience

China Merchants Bank Java Backend Interview: 20 Technical Questions & Answers

A developer shares their successful China Merchants Bank Java backend interview experience, detailing 20 technical questions covering HashMap, ConcurrentHashMap, synchronization, thread pools, Redis cache penetration, MySQL indexing, Spring Boot auto-configuration, Agent memory, RAG, multi-agent orchestration, and more, with answers and preparation tips.

AgentAuto-ConfigurationBackend
0 likes · 35 min read
China Merchants Bank Java Backend Interview: 20 Technical Questions & Answers
Xiaolin Talks Programming
Xiaolin Talks Programming
Sep 22, 2026 · Backend Development

Spring Boot Tomcat Tuning: Breaking the 4K QPS Ceiling with Thread Pool & Keep-Alive Config

This article details how default Spring Boot Tomcat settings (maxThreads=200) cap throughput at ~4K QPS despite low CPU, and demonstrates step-by-step tuning of thread pool, connection limits, and Keep-Alive parameters using Little's Law and load testing to achieve 10K+ QPS with 800 threads and proper monitoring.

Keep-AliveLittle's LawPerformance Tuning
0 likes · 17 min read
Spring Boot Tomcat Tuning: Breaking the 4K QPS Ceiling with Thread Pool & Keep-Alive Config
ITPUB
ITPUB
Sep 15, 2026 · Backend Development

Thread Pool Tuning for 10M SMS/Hour: From Golden Formula to Backpressure

This article dissects a real interview challenge: designing a thread pool to send 10 million SMS messages in one hour. It explains why Executors is dangerous, how to calculate initial thread counts using the golden formula for I/O-bound tasks, why dynamic tuning with monitoring matters, and how CallerRunsPolicy provides natural backpressure in batch scenarios. It also covers reliability patterns like persistence, acknowledgments, and compensation tasks to prevent data loss on crashes.

CallerRunsPolicyInterviewThreadPoolExecutor
0 likes · 10 min read
Thread Pool Tuning for 10M SMS/Hour: From Golden Formula to Backpressure
Xike
Xike
Sep 9, 2026 · Fundamentals

ThreadLocal Internals: How It Works, Why It Leaks, and Safe Usage Patterns

ThreadLocal provides per-thread variable copies via a ThreadLocalMap with weak-reference keys and strong-reference values, enabling request-context storage and non-thread-safe object reuse, but risks memory leaks in long-lived thread pools unless explicitly removed, and requires careful handling for cross-thread propagation.

Best PracticesInheritableThreadLocalJava Concurrency
0 likes · 14 min read
ThreadLocal Internals: How It Works, Why It Leaks, and Safe Usage Patterns
Java Tech Workshop
Java Tech Workshop
Aug 29, 2026 · Backend Development

When a ThreadPool Queue Is Full: How ThreadPoolExecutor Expands and Handles Rejection

The article explains the exact order in which ThreadPoolExecutor expands—core threads, queueing, non‑core threads, then rejection—illustrates the behavior with a runnable example, compares the four built‑in RejectedExecutionHandler strategies, debunks common misconceptions, and offers production‑grade configuration and monitoring best practices.

Java ConcurrencyPerformance TuningThreadPoolExecutor
0 likes · 24 min read
When a ThreadPool Queue Is Full: How ThreadPoolExecutor Expands and Handles Rejection
Java Architect Handbook
Java Architect Handbook
Aug 17, 2026 · Backend Development

Interview Question: What Is Flash‑Sale Warmup and Why Does It Matter?

The article explains warmup (prewarm) as the practice of moving a Java system from a cold to a hot state before traffic arrives, covering JVM JIT compilation, cache preloading, connection‑pool and thread‑pool initialization, service gray‑release, and how these steps prevent cold‑start failures in high‑concurrency scenarios.

CacheConnection PoolJVM
0 likes · 13 min read
Interview Question: What Is Flash‑Sale Warmup and Why Does It Matter?
Random Bulletin
Random Bulletin
Jul 27, 2026 · Backend Development

Isolation Strategies for Ten‑Million‑QPS Services: No Isolation, Thread‑Pool, Semaphore

The article explains how sharing a single thread pool can cause a slow downstream service to cripple an entire high‑traffic system, compares thread‑pool and semaphore isolation—detailing their strengths, costs, and suitable scenarios—and provides practical guidelines, framework support, and design decisions for implementing robust isolation in microservices.

ResilienceSemaphorecircuit breaker
0 likes · 21 min read
Isolation Strategies for Ten‑Million‑QPS Services: No Isolation, Thread‑Pool, Semaphore
Programmer1970
Programmer1970
Jul 21, 2026 · Backend Development

How to Cut RocketMQ Consumer Latency from 10 s to 500 ms with Five Overlooked Settings

During a traffic peak the order service saw 30‑second consumer latency and a backlog of over 20 000 messages; by adjusting five RocketMQ consumer parameters—pullBatchSize, consumeThreadMin/Max, adjustThreadPoolNumsThreshold, pullTimeoutMillis, socketTimeoutMillis, and consumeMessageBatchMaxSize—the team reduced end‑to‑end latency to 500 ms, raised TPS to over 2500, and cleared the backlog.

Performance TuningRocketMQconfiguration
0 likes · 9 min read
How to Cut RocketMQ Consumer Latency from 10 s to 500 ms with Five Overlooked Settings
Random Bulletin
Random Bulletin
Jul 21, 2026 · Backend Development

Thread Pool Design for Million‑QPS Systems: From Shared to Isolated

The article explains how a shared thread pool can turn a localized slowdown into a system‑wide outage, then walks through the bulkhead isolation pattern, bounded queues, trade‑offs between thread‑pool and semaphore isolation, sizing formulas, monitoring metrics, and dynamic tuning for high‑QPS services.

Concurrencybulkhead patterndynamic thread pool
0 likes · 16 min read
Thread Pool Design for Million‑QPS Systems: From Shared to Isolated
Java Tech Workshop
Java Tech Workshop
Jul 21, 2026 · Backend Development

A Lighter‑Than‑MQ Async Solution: Spring’s Hidden Transactional Event Feature

The article explains how Spring’s built‑in @Async and TransactionalEventListener mechanisms provide a lightweight, zero‑dependency alternative to external message queues for local asynchronous processing, detailing their advantages, limitations, and production‑grade enhancements such as custom thread pools, dead‑letter persistence, and clustering strategies.

JavaMessage QueueSpring
0 likes · 17 min read
A Lighter‑Than‑MQ Async Solution: Spring’s Hidden Transactional Event Feature
Tinker Programmer
Tinker Programmer
Jul 17, 2026 · Backend Development

How Java 21 Virtual Threads Enable 100 k Threads Without Thread‑Pool Tuning

After weeks of futile thread‑pool tuning for an IO‑bound gateway, the author switched to Java 21 virtual threads, achieving stable 5,000 concurrent requests with dramatically lower P99 latency, reduced memory usage, and higher CPU efficiency, and then explains virtual‑thread internals, Scoped Values, migration steps, and limitations.

ConcurrencyJavaScoped Values
0 likes · 18 min read
How Java 21 Virtual Threads Enable 100 k Threads Without Thread‑Pool Tuning
Random Bulletin
Random Bulletin
Jul 14, 2026 · Backend Development

When 10 Million QPS Hits: Why Switching from Sync to Async Becomes Mandatory

The article explains how, at the ten‑million‑QPS scale, the hidden cost of thread‑bound synchronous calls—memory, scheduling overhead, and stability risks—explodes, making asynchronous architectures essential, and outlines the trade‑offs, gradual migration paths, and scenarios where async should or should not be applied.

Asynchronous ProgrammingPerformance Optimizationhigh-concurrency
0 likes · 19 min read
When 10 Million QPS Hits: Why Switching from Sync to Async Becomes Mandatory
samdeepthink
samdeepthink
Jul 14, 2026 · Backend Development

Thread‑Pool Outage Postmortem: Four Defense Layers to Prevent Data Loss

A July 13 incident revealed that sharing a single thread pool across order, refund, and status sync services caused queue saturation, task rejection, and data loss, prompting a four‑layer defense—pool isolation, CallerRunsPolicy with structured alerts, minute‑level DingTalk notifications, and a compensation tool—to ensure reliability and quick recovery.

ConcurrencyFault ToleranceJava
0 likes · 10 min read
Thread‑Pool Outage Postmortem: Four Defense Layers to Prevent Data Loss
ITPUB
ITPUB
Jul 8, 2026 · Databases

MySQL 26.7 EA Arrives: Calendar Versioning Jumps to 26 and Community Edition Evolves

MySQL 26.7.0 Early Access introduces calendar versioning that jumps the version number to 26, adds post‑quantum TLS support, a new Change Stream Applier, InnoDB refactoring, and moves the thread‑pool plugin to the community edition, while Oracle expands governance with a steering committee, a public roadmap, and a detailed release schedule for 2026‑2027.

Calendar VersioningChange Stream ApplierDatabase Governance
0 likes · 16 min read
MySQL 26.7 EA Arrives: Calendar Versioning Jumps to 26 and Community Edition Evolves
Architect Chen
Architect Chen
Jun 16, 2026 · Backend Development

A Complete Illustrated Guide to Java Concurrency for High‑Performance Architecture

This article provides a thorough, image‑rich overview of Java concurrency, covering the differences between concurrency and parallelism, thread lifecycle states, various ways to create threads, thread‑pool design and workflow, the Java Memory Model, and essential JUC utilities, all illustrated with code snippets and diagrams.

ConcurrencyJUCJava
0 likes · 8 min read
A Complete Illustrated Guide to Java Concurrency for High‑Performance Architecture
samdeepthink
samdeepthink
Jun 1, 2026 · Backend Development

Why One ThreadLocal Instance Suffices for an Entire Business Scenario

The article explains that a single ThreadLocal object can be shared across dozens of threads because the actual data lives in each thread's own ThreadLocalMap, outlines how set/get work, highlights thread‑pool pitfalls such as stale data and memory leaks, and provides best‑practice guidelines for static declaration, proper removal, and using TransmittableThreadLocal for cross‑thread propagation.

ConcurrencyJavaMemory Leak
0 likes · 10 min read
Why One ThreadLocal Instance Suffices for an Entire Business Scenario
Su San Talks Tech
Su San Talks Tech
Jun 1, 2026 · Backend Development

Can Java 21’s Virtual Threads Make Thread Pools Obsolete?

The article examines whether Java 21’s cheap virtual threads can replace traditional thread pools, explaining the original purpose of pools, their role as natural throttlers, scenarios where virtual threads excel or fail, and practical guidelines to avoid pitfalls like pinning.

ConcurrencyJavaJava 21
0 likes · 7 min read
Can Java 21’s Virtual Threads Make Thread Pools Obsolete?
Java Tech Workshop
Java Tech Workshop
May 27, 2026 · Backend Development

SpringBoot Consumer Concurrency: Tuning Thread Pools to Prevent MQ Backlog

In distributed systems, MQ message pile‑up, consumption delays, and service stalls are often caused by poorly configured consumer thread pools, and this article explains the underlying concurrency model, core parameters, custom pool setup, tuning formulas, common pitfalls, and best‑practice configurations for SpringBoot RabbitMQ consumers.

ConcurrencyRabbitMQSpringBoot
0 likes · 13 min read
SpringBoot Consumer Concurrency: Tuning Thread Pools to Prevent MQ Backlog
Lobster Programming
Lobster Programming
May 18, 2026 · Fundamentals

Why userId Gets Lost in Async Calls and How ThreadLocal Solves It

The article explains ThreadLocal's lifecycle, why userId disappears when spawning asynchronous threads, compares ThreadLocal, InheritableThreadLocal, and Alibaba's TransmittableThreadLocal, and shows how the latter prevents data contamination in thread‑pool reuse.

InheritableThreadLocalJava ConcurrencyThreadLocal
0 likes · 5 min read
Why userId Gets Lost in Async Calls and How ThreadLocal Solves It
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
May 8, 2026 · Backend Development

How to Achieve Asynchronous Thread‑Pool Traceability in Spring Boot with MDC

In high‑concurrency microservices, Spring Boot's default async thread pool loses the MDC‑based traceId, making log correlation impossible; this article shows how to capture the traceId in a filter, propagate it with a custom ThreadPoolTaskExecutor and MDC task decorator, and extend the solution to Feign, RestTemplate, and RestClient while demonstrating a price‑aggregation use case.

LoggingMDCSpring Boot
0 likes · 11 min read
How to Achieve Asynchronous Thread‑Pool Traceability in Spring Boot with MDC
ITPUB
ITPUB
Apr 10, 2026 · Backend Development

How a Simple Refactor and Parallelism Cut Java Loop Time from 26s to 0.7s

A new team member transformed a painfully slow Java data‑processing routine—originally taking 26,856 ms—by refactoring nested loops, extracting repeated calculations, and introducing a thread‑pool for parallel execution, reducing runtime to just 748 ms, and the article walks through the before‑and‑after code and key techniques.

JavaPerformance Optimizationparallel computing
0 likes · 8 min read
How a Simple Refactor and Parallelism Cut Java Loop Time from 26s to 0.7s
JD Tech
JD Tech
Apr 9, 2026 · Databases

How DongSQL Solves E‑Commerce DB Overload, Flash‑Sale, and Plan Drift

This article analyzes JD's self‑developed database kernel DongSQL, describing its architecture, the challenges of overload, flash‑sale write spikes, cache consistency, execution‑plan drift, and thread congestion, and explains how hint‑based limiting, RETURNING syntax, statement outlines, and a built‑in thread pool address each issue.

HintSQL Optimizationdatabase
0 likes · 22 min read
How DongSQL Solves E‑Commerce DB Overload, Flash‑Sale, and Plan Drift
Architect's Guide
Architect's Guide
Apr 1, 2026 · Backend Development

Master AsyncTask Orchestration in Spring Boot with asyncTool

This guide explains how to integrate asyncTool into a Spring Boot project, configure custom thread pools, understand core interfaces like IWorker and ICallback, and implement serial, parallel, and mixed task flows with detailed code examples and best‑practice considerations.

ConcurrencyJavaSpring Boot
0 likes · 11 min read
Master AsyncTask Orchestration in Spring Boot with asyncTool
java1234
java1234
Mar 31, 2026 · Backend Development

How Many Concurrent Requests Can Spring Boot Handle?

This article explains how Spring Boot processes concurrent HTTP requests using its embedded Tomcat thread pool, details the default limits (200 max threads, 10 min threads, queue size 10,000), shows how to tune these settings via configuration files, demonstrates async controllers, and suggests performance testing tools to measure real‑world capacity.

ConcurrencySpring BootTomcat
0 likes · 7 min read
How Many Concurrent Requests Can Spring Boot Handle?
LuTiao Programming
LuTiao Programming
Mar 15, 2026 · Backend Development

How Java Virtual Threads Eliminate Thread‑Pool Bottlenecks and Enable a Single Machine to Handle 100k Requests

The article explains why traditional OS‑based thread pools choke under 100,000 concurrent Java requests, introduces Java 21's Virtual Threads from Project Loom, shows their low‑memory, high‑throughput characteristics, provides Spring Boot configuration and code samples, and warns about synchronization, ThreadLocal and CPU‑bound pitfalls.

ConcurrencyI/OJava
0 likes · 10 min read
How Java Virtual Threads Eliminate Thread‑Pool Bottlenecks and Enable a Single Machine to Handle 100k Requests
Java Tech Enthusiast
Java Tech Enthusiast
Feb 8, 2026 · Backend Development

Mastering AsyncTask Orchestration in Spring Boot with asyncTool

This guide shows how to integrate the asyncTool library into a Spring Boot project, configure custom thread pools, understand its core interfaces, and use code examples to build serial, parallel, and mixed task workflows with full monitoring, fault tolerance, and performance optimizations.

asyncbackend-developmentspring-boot
0 likes · 12 min read
Mastering AsyncTask Orchestration in Spring Boot with asyncTool
Java Architect Handbook
Java Architect Handbook
Feb 7, 2026 · Backend Development

Master AsyncTask Orchestration in Spring Boot with asyncTool

This guide explains how to integrate the asyncTool library into a Spring Boot project, configure custom thread pools, understand core interfaces like IWorker and ICallback, and use the provided Builder API to define serial, parallel, and mixed task flows with detailed code examples and best‑practice cautions.

ConcurrencyJavaSpring Boot
0 likes · 13 min read
Master AsyncTask Orchestration in Spring Boot with asyncTool
DevOps Coach
DevOps Coach
Jan 21, 2026 · Operations

How I Turned a 3‑Day Latency Nightmare into a 30‑Second Debugging Tool

After a late‑night PagerDuty alert revealed a p95 latency over 5 seconds despite normal CPU, memory, and database metrics, the author spent three days tracing the issue to a tiny thread‑pool configuration, then built an open‑source CLI that automates the entire diagnosis in seconds.

Connection PoolGrafanalatency debugging
0 likes · 17 min read
How I Turned a 3‑Day Latency Nightmare into a 30‑Second Debugging Tool
Tech Freedom Circle
Tech Freedom Circle
Dec 17, 2025 · Backend Development

Thread Pool: Shared vs Exclusive – How to Choose the Right Strategy for Critical Java Services

This article dissects the interview question “Should thread pools be shared or exclusive?” by exposing common pitfalls, presenting a systematic analysis of isolation versus reuse, and illustrating best‑practice designs with concrete RocketMQ examples, code snippets, and decision‑making guidelines.

Java ConcurrencyRocketMQisolation
0 likes · 22 min read
Thread Pool: Shared vs Exclusive – How to Choose the Right Strategy for Critical Java Services
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Dec 17, 2025 · Backend Development

When to Share or Isolate Thread Pools? A Deep Dive for Java Backend Architects

This article explains the trade‑offs between using a shared thread pool and creating dedicated pools in Java backend services, outlines scenario‑based decision rules, provides concrete Spring‑Boot configuration examples, and offers advanced dynamic tuning and interview‑style Q&A for reliable concurrency management.

ConcurrencyJavaSpring Boot
0 likes · 14 min read
When to Share or Isolate Thread Pools? A Deep Dive for Java Backend Architects
Su San Talks Tech
Su San Talks Tech
Dec 5, 2025 · Backend Development

Unlocking Java ThreadPoolExecutor: Deep Dive, Best Practices, and Real‑World Tuning

This article provides a comprehensive exploration of Java's ThreadPoolExecutor, covering why thread pools are essential, how the executor framework is designed, detailed source‑code analysis of core classes, parameter tuning, rejection policies, monitoring techniques, and practical best‑practice recommendations for production systems.

ConcurrencyJavaPerformance Tuning
0 likes · 32 min read
Unlocking Java ThreadPoolExecutor: Deep Dive, Best Practices, and Real‑World Tuning
Deepin Linux
Deepin Linux
Nov 28, 2025 · Backend Development

Boosting C++ Thread Pool Performance: Queue and Memory Optimizations

This article explains why C++ thread pools often hit bottlenecks in high‑concurrency scenarios and provides practical techniques—such as lock‑granularity tuning, lock‑free queues, object‑pool reuse, and pre‑allocation—to improve task scheduling and memory management without relying on external frameworks.

C++ConcurrencyOptimization
1 likes · 44 min read
Boosting C++ Thread Pool Performance: Queue and Memory Optimizations
Ubiquitous Tech
Ubiquitous Tech
Nov 24, 2025 · Backend Development

DynamicTp Startup and Configuration Change Flow: A Deep Dive into Dynamic Thread Pool Design

This article walks through the internal startup sequence and runtime configuration‑change mechanism of the open‑source DynamicTp dynamic thread‑pool, covering Spring Boot starter integration, @EnableDynamicTp annotation processing, Nacos‑driven property refresh, SPI extensibility, queue adaptation, and graceful shutdown, all illustrated with concrete code snippets and diagrams.

Configuration RefreshDynamicTpJava Concurrency
0 likes · 16 min read
DynamicTp Startup and Configuration Change Flow: A Deep Dive into Dynamic Thread Pool Design
Ubiquitous Tech
Ubiquitous Tech
Nov 10, 2025 · Backend Development

DynamicTp Explained: Dynamically Adjust Java Thread Pools with Zero‑Code Intrusion

This article introduces DynamicTp, a lightweight, configuration‑center‑driven dynamic thread‑pool library for Java, explains why static pools are problematic, details its features such as runtime parameter adjustment, visual monitoring, smart alerts and middleware integration, and walks through a complete Spring Boot 2.7 demo with Nacos and Feishu notifications.

DynamicTpJavaNacos
0 likes · 17 min read
DynamicTp Explained: Dynamically Adjust Java Thread Pools with Zero‑Code Intrusion
Su San Talks Tech
Su San Talks Tech
Nov 4, 2025 · Backend Development

How I Boosted a Java Backend’s Throughput from 50/s to 500/s: A Real‑World Performance Debugging Journey

In this detailed case study, the author walks through diagnosing and fixing severe throughput bottlenecks in a Java Spring‑based B2B service, covering lock contention, slow SQL, excessive logging, thread‑pool tuning, JVM memory adjustments, and the impact of bean creation on performance, ultimately achieving nearly a ten‑fold increase in requests per second.

JavaSpringprofiling
0 likes · 14 min read
How I Boosted a Java Backend’s Throughput from 50/s to 500/s: A Real‑World Performance Debugging Journey
Architect
Architect
Nov 2, 2025 · Backend Development

How to Optimize Java Thread Pools for 100k QPS: Strategies & Code

Learn how to handle 100,000 QPS with 100 ms tasks by analyzing standard thread pool limitations, setting clear optimization goals, applying strategies like batch processing, custom thread pool parameters, rejection handling, and advanced techniques such as Disruptor, rate limiting, and circuit breaking, complete with annotated Java code examples.

JavaSpring Bootthread pool
0 likes · 8 min read
How to Optimize Java Thread Pools for 100k QPS: Strategies & Code
Code Ape Tech Column
Code Ape Tech Column
Oct 21, 2025 · Backend Development

Mastering AsyncTask Orchestration in Spring Boot with asyncTool

Learn how to integrate asyncTool into a Spring Boot project, configure custom thread pools, understand core interfaces like IWorker and ICallback, and implement serial, parallel, and mixed task flows with detailed code examples and best‑practice guidelines for robust asynchronous task orchestration.

JavaSpring BootasyncTool
0 likes · 12 min read
Mastering AsyncTask Orchestration in Spring Boot with asyncTool
Tech Freedom Circle
Tech Freedom Circle
Sep 28, 2025 · Backend Development

Midnight TODO That Nearly Crashed the Whole Department: A JVM Performance Tuning Case Study

During a midnight promotion launch, a forgotten TODO caused thread‑pool exhaustion and frequent Full GC, bringing down an e‑commerce service; the article presents a five‑step end‑to‑end JVM tuning methodology, from data collection to root‑cause verification and code fix, showing how to diagnose and resolve such incidents.

Full GCHeap DumpJVM
0 likes · 24 min read
Midnight TODO That Nearly Crashed the Whole Department: A JVM Performance Tuning Case Study
DeWu Technology
DeWu Technology
Sep 24, 2025 · Backend Development

Master Java Thread Pools: Deep Dive into JDK ThreadPoolExecutor Architecture

This article explains why thread pools are essential for performance, explores the JDK ThreadPoolExecutor’s internal architecture, parameters, lifecycle states, common pitfalls, and provides practical best‑practice guidelines—including handling invokeAll timeouts, submit exceptions, rejection policies, and pool isolation techniques—to help developers use thread pools safely and efficiently.

Best PracticesJavaThreadPoolExecutor
0 likes · 38 min read
Master Java Thread Pools: Deep Dive into JDK ThreadPoolExecutor Architecture
Java Architecture Diary
Java Architecture Diary
Sep 22, 2025 · Backend Development

Unlock Massive Concurrency: How Java 25 Virtual Threads Supercharge Spring Apps

Java 25 introduces major upgrades to virtual threads, offering dramatically lower memory usage, near‑zero creation cost, and efficient I/O handling, and this guide explains their advantages, compares them with traditional thread pools and @Async, provides Spring Boot 3.5 configuration examples, and highlights pitfalls and best‑practice tips.

ConcurrencySpringVirtual Threads
0 likes · 8 min read
Unlock Massive Concurrency: How Java 25 Virtual Threads Supercharge Spring Apps
IT Services Circle
IT Services Circle
Sep 17, 2025 · Backend Development

Ace ByteDance Java Interview: Concurrency, Thread Pools, Redis & MySQL Deep Dive

This article walks through essential ByteDance Java interview topics, covering thread safety fundamentals, thread‑pool configuration, Redis performance tricks, Zset and skip‑list internals, memory‑policy handling, cache‑consistency patterns, and MySQL transaction ACID properties, providing code examples and best‑practice recommendations.

Cache ConsistencyJava ConcurrencyMySQL transaction
0 likes · 25 min read
Ace ByteDance Java Interview: Concurrency, Thread Pools, Redis & MySQL Deep Dive
Java Tech Enthusiast
Java Tech Enthusiast
Sep 10, 2025 · Backend Development

Automate MinIO Image Cleanup with Spring Boot Scheduled Tasks and Cron

This guide explains how to use MinIO SDK in a Spring Boot application to schedule automatic deletion of outdated image folders, covering dependency setup, delete methods, performance considerations, cron expression configuration, thread‑pool tuning, asynchronous execution, and extensible configuration via properties.

File CleanupMinIOSpring Boot
0 likes · 26 min read
Automate MinIO Image Cleanup with Spring Boot Scheduled Tasks and Cron
IT Services Circle
IT Services Circle
Aug 30, 2025 · Operations

Why Does My System Freeze? 9 Common Causes and How to Diagnose Them

This article explains why systems suddenly become unresponsive, outlines nine typical root causes ranging from frontend request spikes to backend thread‑pool exhaustion and missing timeout settings, and walks through a real‑world investigation that reveals how to pinpoint and resolve such blockages.

JavaSpringTimeout
0 likes · 11 min read
Why Does My System Freeze? 9 Common Causes and How to Diagnose Them
Huolala Tech
Huolala Tech
Aug 13, 2025 · Backend Development

Why Do Inherited ThreadLocals Cause Task Failures in XXL‑Job?

An in‑depth analysis reveals that stale parameters stored in InheritableThreadLocal objects during thread‑pool reuse cause XXL‑Job tasks to process incorrect data, and provides debugging steps and best‑practice recommendations to prevent context pollution.

Context PropagationDebuggingInheritableThreadLocal
0 likes · 10 min read
Why Do Inherited ThreadLocals Cause Task Failures in XXL‑Job?
Liangxu Linux
Liangxu Linux
Aug 5, 2025 · Fundamentals

Master C++11 Condition Variables: From Basics to Thread‑Pool Mastery

This article explains what C++11 condition variables are, why they are essential for efficient multithreading, shows their basic usage with std::condition_variable and std::mutex, walks through a producer‑consumer example, demonstrates a thread‑pool implementation, and lists crucial best‑practice tips.

C++C++11Concurrency
0 likes · 15 min read
Master C++11 Condition Variables: From Basics to Thread‑Pool Mastery
Mingyi World Elasticsearch
Mingyi World Elasticsearch
Jul 31, 2025 · Operations

How to Fix Elasticsearch Sync Bottlenecks: Practical Optimization Steps

This article walks through a real‑world case where syncing over 12 million records to Elasticsearch stalled, analyzes memory pressure, thread‑pool limits, and Netty I/O logs, and then presents concrete configuration tweaks, batch‑by‑time‑slice loading, DSL bulk‑API adjustments, and cluster‑health monitoring that reduced the import time to about two hours.

ElasticsearchPerformance Tuningbulk API
0 likes · 6 min read
How to Fix Elasticsearch Sync Bottlenecks: Practical Optimization Steps
macrozheng
macrozheng
Jul 17, 2025 · Backend Development

How We Resolved Repeated Kafka Message Backlogs in a High‑Traffic Restaurant System

This article recounts a series of Kafka message backlog incidents in a restaurant ordering system and explains how targeted optimizations—batch database queries, index tuning, data archiving, and thread‑pool scaling—eliminated the delays and restored reliable kitchen display performance.

KafkaMessage QueuePerformance Optimization
0 likes · 12 min read
How We Resolved Repeated Kafka Message Backlogs in a High‑Traffic Restaurant System
Java Architect Essentials
Java Architect Essentials
Jul 7, 2025 · Backend Development

6 Proven Spring Boot Performance Hacks to Slash Response Time

Discover six practical Spring Boot optimization techniques—including Tomcat thread‑pool tuning, @Async asynchronous processing, HTTP caching, switching to Undertow, HikariCP connection pooling, and JVM memory settings—that transformed a sluggish e‑commerce service from 5‑second delays to sub‑1.5‑second response times.

HTTP cachingHikariCPSpring Boot
0 likes · 11 min read
6 Proven Spring Boot Performance Hacks to Slash Response Time
Architect
Architect
Jul 4, 2025 · Backend Development

Async Requests in Spring Boot: Callable, WebAsyncTask & DeferredResult

This article explains how Spring Boot supports asynchronous request processing, comparing pre‑Servlet 3.0 synchronous handling with post‑Servlet 3.0 async features, and demonstrates four implementation approaches—Callable, WebAsyncTask, DeferredResult, and thread‑pool configuration—while outlining when asynchronous requests improve throughput and how to manage their lifecycle.

Spring Bootasynchronouscallable
0 likes · 10 min read
Async Requests in Spring Boot: Callable, WebAsyncTask & DeferredResult
Architect
Architect
Jun 30, 2025 · Backend Development

Boost Java Performance: 12 Proven Techniques for Faster, Scalable Backend Systems

This article presents twelve practical strategies for optimizing Java backend performance—including parallel processing with CompletableFuture, minimizing transaction scope, effective caching, proper thread‑pool configuration, service warm‑up, cache‑line alignment, reducing object creation, asynchronous execution, loop optimization, shrinking network payloads, and decreasing inter‑service dependencies—each illustrated with code examples and benchmark results.

ConcurrencyJavaasync
0 likes · 33 min read
Boost Java Performance: 12 Proven Techniques for Faster, Scalable Backend Systems
Java Architect Essentials
Java Architect Essentials
May 25, 2025 · Backend Development

Simplifying Asynchronous Tasks in Spring Boot with @Async Annotation

Spring Boot's @Async annotation enables developers to replace manual thread and thread‑pool management with simple method annotations, providing automatic asynchronous execution, customizable thread pools, and flexible return types such as Future and CompletableFuture, thereby streamlining code, improving efficiency, and reducing complexity in backend services.

JavaSpringBootasync
0 likes · 7 min read
Simplifying Asynchronous Tasks in Spring Boot with @Async Annotation
Java One
Java One
May 19, 2025 · Backend Development

Mastering Non‑Blocking IO Pipelines in Java: Design Challenges and Solutions

This article examines the difficulties of building non‑blocking services with Java NIO, compares blocking and non‑blocking pipelines, and presents practical designs for handling partial reads, dynamic buffers, message framing, and efficient write management to scale servers to millions of connections.

Java NIOSelectormessage parsing
0 likes · 19 min read
Mastering Non‑Blocking IO Pipelines in Java: Design Challenges and Solutions
Java Backend Full-Stack
Java Backend Full-Stack
Apr 26, 2025 · Backend Development

Master ThreadLocal: Answer Interview Questions and Prevent OOM Leaks

This article explains ThreadLocal’s internal mechanism, why improper use can cause OutOfMemoryError in thread pools, demonstrates the issue with a Java example, and provides best‑practice guidance—especially calling remove()—to prevent memory leaks while preparing for interview questions.

ConcurrencyJavaMemory Leak
0 likes · 11 min read
Master ThreadLocal: Answer Interview Questions and Prevent OOM Leaks
Deepin Linux
Deepin Linux
Apr 20, 2025 · Backend Development

Understanding IOCP: Windows Asynchronous I/O Completion Port

This article explains the IOCP (I/O Completion Port) mechanism in Windows, covering its principles, advantages, core components, workflow, practical usage steps with code examples, comparisons to other asynchronous models, and common pitfalls such as thread synchronization, memory management, error handling, and load balancing.

IOCPasynchronous I/Othread pool
0 likes · 31 min read
Understanding IOCP: Windows Asynchronous I/O Completion Port
Cognitive Technology Team
Cognitive Technology Team
Apr 15, 2025 · Backend Development

Using Traceable Thread Pools in Spring Cloud to Preserve Trace Context

This article explains why and how to enforce the use of trace‑aware thread pools in Spring Cloud, presenting three approaches—including TraceableExecutorService, Tracer.currentTraceContext().wrap, and TraceCallable/TraceRunnable—to prevent loss of distributed tracing information in multithreaded applications.

JavaSleuthSpring Cloud
0 likes · 4 min read
Using Traceable Thread Pools in Spring Cloud to Preserve Trace Context
Programmer Xu Shu
Programmer Xu Shu
Feb 24, 2025 · Backend Development

Mastering Thread Pool Tuning: Real‑World Strategies from a Meituan Interview

This article breaks down essential thread‑pool parameters, explains how to set corePoolSize and maximumPoolSize for CPU‑ and IO‑bound tasks, and outlines a practical, dynamic adjustment process—including monitoring, strategy definition, load testing, and automation—to achieve optimal performance in production environments.

Dynamic ScalingJava ConcurrencyPerformance Tuning
0 likes · 8 min read
Mastering Thread Pool Tuning: Real‑World Strategies from a Meituan Interview
Java Backend Technology
Java Backend Technology
Feb 14, 2025 · Backend Development

Master Efficient Excel Import/Export in Java with EasyExcel and Thread Pools

Learn how to efficiently handle large-scale Excel import and export in Java web applications using EasyExcel, leveraging Java 8 functional programming, reflection, thread pools, and custom ReadListener implementations to minimize memory usage, improve performance, and support flexible data mapping and dynamic schema handling.

EasyExcelSpring Bootdata export
0 likes · 14 min read
Master Efficient Excel Import/Export in Java with EasyExcel and Thread Pools
Java Tech Enthusiast
Java Tech Enthusiast
Feb 5, 2025 · Backend Development

Optimizing Large-Scale Excel Import/Export in Java with EasyExcel and Thread Pools

By combining EasyExcel’s low‑memory parsing with Java 8 functional style, reflection‑based generic annotations, a thread‑pool‑driven batch listener, and flexible export utilities that support dynamic headers and map‑based rows, Java back‑ends can safely import and export millions of Excel rows without OOM errors.

EasyExcelJavadata processing
0 likes · 13 min read
Optimizing Large-Scale Excel Import/Export in Java with EasyExcel and Thread Pools
Selected Java Interview Questions
Selected Java Interview Questions
Jan 7, 2025 · Backend Development

Spring Boot Asynchronous Processing: Principles, Configuration, and Practical Use Cases

This article explains Spring Boot’s asynchronous processing mechanism, covering its purpose, the @Async annotation, configuration steps, custom thread pool setup, handling return values, and typical use cases, enabling developers to improve performance and responsiveness in backend applications.

Asynchronous ProcessingJavaSpring Boot
0 likes · 9 min read
Spring Boot Asynchronous Processing: Principles, Configuration, and Practical Use Cases
ITPUB
ITPUB
Dec 25, 2024 · Backend Development

How a Low Guava RateLimiter Triggered RPC Thread‑Pool Exhaustion

A developer investigates why an RPC service suddenly rejected many requests, discovers that a Guava RateLimiter with a limit of only ten calls per minute caused thread‑pool saturation, and explains the misinterpretations, monitoring data, and steps taken to pinpoint the root cause.

BackendRate Limiterthread pool
0 likes · 10 min read
How a Low Guava RateLimiter Triggered RPC Thread‑Pool Exhaustion
Top Architect
Top Architect
Dec 15, 2024 · Backend Development

Deep Dive into Spring Boot 2.7.10 Embedded Tomcat Configuration, Thread Management and Performance Testing

This article provides a comprehensive analysis of Spring Boot 2.7.10's embedded Tomcat 9.0.73 default settings, core parameters, internal thread architecture, configuration examples, performance testing with various concurrent connections, and includes detailed code snippets and diagrams, while also containing promotional material for AI services.

Spring BootTomcatconfiguration
0 likes · 17 min read
Deep Dive into Spring Boot 2.7.10 Embedded Tomcat Configuration, Thread Management and Performance Testing
Liangxu Linux
Liangxu Linux
Dec 2, 2024 · Backend Development

Build a Minimal C Thread Pool on Linux – Full Code Walkthrough

This article presents a compact C thread‑pool implementation for Linux using POSIX pthreads, explains the core data structures and functions, shows how to create, enqueue tasks, and destroy the pool, and includes a runnable demo with annotated source code.

Linuxpthreadsthread pool
0 likes · 7 min read
Build a Minimal C Thread Pool on Linux – Full Code Walkthrough
Programmer1970
Programmer1970
Nov 27, 2024 · Operations

Understanding Elasticsearch Thread Pools: Types, Usage, and Tuning

The article explains Elasticsearch's thread‑pool architecture, detailing the Search, Write, Generic, and other specialized pools, their purposes, fixed or cached configurations, optimization guidelines, and how to monitor and adjust them via REST APIs and built‑in tools.

ElasticsearchJava ExecutorPerformance Tuning
0 likes · 7 min read
Understanding Elasticsearch Thread Pools: Types, Usage, and Tuning
Code Ape Tech Column
Code Ape Tech Column
Nov 8, 2024 · Backend Development

Implementing a Dynamic Thread Pool with Nacos in Spring Boot

This article explains how to externalize and dynamically adjust a Spring Boot thread pool's core and maximum sizes using Nacos as a configuration center, allowing runtime changes without service restarts and demonstrating the setup, code, and testing procedures.

Dynamic ConfigurationJavaNacos
0 likes · 9 min read
Implementing a Dynamic Thread Pool with Nacos in Spring Boot
macrozheng
macrozheng
Oct 24, 2024 · Backend Development

Master Java Thread Pools: Boost Performance and Avoid Resource Pitfalls

This article explains why creating a thread for each task is inefficient, introduces thread pools as a solution, compares execution times with code examples, details ThreadPoolExecutor's core interfaces, constructors, execution flow, rejection policies, state transitions, and provides practical usage patterns and best‑practice recommendations for Java backend development.

ConcurrencyExecutorServiceJava
0 likes · 28 min read
Master Java Thread Pools: Boost Performance and Avoid Resource Pitfalls
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Oct 13, 2024 · Backend Development

How Spring Boot Handles Async Tasks and Thread Pools: Deep Dive & Customization

This article explores Spring Boot's asynchronous task and request mechanisms, detailing how @EnableAsync, @Async, @EnableScheduling, and @Async annotations configure thread pools, examines the underlying source code, and demonstrates custom configurations for executors and schedulers to control concurrency.

AsyncSpring BootTask Scheduling
0 likes · 14 min read
How Spring Boot Handles Async Tasks and Thread Pools: Deep Dive & Customization
Shepherd Advanced Notes
Shepherd Advanced Notes
Sep 24, 2024 · Backend Development

How to Properly Configure ThreadPoolExecutor Parameters in Java

This article explains the background, creation, and detailed parameters of Java's ThreadPoolExecutor, walks through its task execution flow, warns against using Executors factory methods, and provides practical formulas for setting core pool sizes based on CPU‑bound or I/O‑bound workloads.

CPUConcurrencyExecutorService
0 likes · 15 min read
How to Properly Configure ThreadPoolExecutor Parameters in Java
Programmer1970
Programmer1970
Sep 22, 2024 · Backend Development

15 Proven Techniques to Optimize API Performance

This article enumerates fifteen practical techniques—including local and distributed caching, parallelism, asynchrony, pooling, sharding, SQL tuning, pre‑computation, transaction trimming, bulk I/O, lock granularity, context propagation, collection sizing, and query optimization—to systematically improve the response time and throughput of service interfaces.

APIConcurrencySQL
0 likes · 14 min read
15 Proven Techniques to Optimize API Performance
Java Tech Enthusiast
Java Tech Enthusiast
Sep 10, 2024 · Backend Development

Thread Pool Data Persistence in Java Systems

The article explains how using a database‑backed persistence layer for Java thread‑pool tasks prevents data loss during service downtime by storing tasks before submission, tracking status and retries, and employing idempotent processing with configurable pool sizes and scheduled reprocessing of failed or pending jobs.

Javabackend developmentdata persistence
0 likes · 7 min read
Thread Pool Data Persistence in Java Systems
Su San Talks Tech
Su San Talks Tech
Aug 30, 2024 · Backend Development

Prevent Data Loss in Java Thread Pools When Services Crash

This article explains Java thread pools, their advantages, internal mechanics, common pitfalls such as oversized queues, excessive threads, and data loss on crashes, and presents a persistence‑based solution using database‑stored tasks and scheduled retries to ensure no data is lost when services go down.

ConcurrencyJavaOOM prevention
0 likes · 8 min read
Prevent Data Loss in Java Thread Pools When Services Crash
Sanyou's Java Diary
Sanyou's Java Diary
Jul 22, 2024 · Backend Development

Why Does My ThreadPool Freeze? Uncovering the Hidden Deadlock Pitfall

This article explains a subtle thread‑pool deadlock caused by parent‑child task interactions, demonstrates the issue with a reproducible demo, analyzes why the latch logic fails, and provides a practical solution of isolating thread pools to avoid false‑deadlock behavior in microservices.

CountDownLatchDeadlockJava
0 likes · 11 min read
Why Does My ThreadPool Freeze? Uncovering the Hidden Deadlock Pitfall
Sohu Tech Products
Sohu Tech Products
Jul 17, 2024 · Backend Development

Java Thread Pool: Working Mechanism, States, and Rejection Policies

Java thread pools efficiently manage and reuse threads by applying a producer‑consumer model, transitioning through RUNNING, SHUTDOWN, STOP, and TERMINATED states, handling task queues, and employing configurable rejection policies such as Abort, CallerRuns, Discard, and DiscardOldest, while improving performance, resource utilization, and stability across web servers, asynchronous processing, and other concurrent workloads, distinct from connection pools which manage database connections.

ConcurrencyJavaJava Concurrency
0 likes · 12 min read
Java Thread Pool: Working Mechanism, States, and Rejection Policies