BestHub
Sign in
Tagged articles

thread pool

241 articles · Page 1 of 3
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.

JUCJavaconcurrency
0 likes · 8 min read
A Complete Illustrated Guide to Java Concurrency for High‑Performance Architecture
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.

JavaJava 21concurrency
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.

PrefetchRabbitMQYAML
0 likes · 13 min read
SpringBoot Consumer Concurrency: Tuning Thread Pools to Prevent MQ Backlog
360 Zhihui Cloud Developer
360 Zhihui Cloud Developer
May 21, 2026 · Backend Development

Optimizing Ozone S3 Gateway with Fast/Slow Dual‑Queue Isolation and Rate‑Limiting

The article presents a fast/slow dual‑queue isolation and water‑level rate‑limiting design for the Ozone S3 gateway, detailing separate thread pools, async handling, bucket‑level throttling, and comprehensive metrics that together improve service stability and throughput under mixed workloads.

Async ProcessingFast/Slow QueueJetty
0 likes · 10 min read
Optimizing Ozone S3 Gateway with Fast/Slow Dual‑Queue Isolation and Rate‑Limiting
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.

LoggingMDCMicroservices
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.

Hintdatabasee-commerce
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.

JavaSpring BootasyncTool
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.

Spring Bootasyncconcurrency
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.

I/OJavaProject Loom
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.

Backend DevelopmentJavaSpring 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.

JavaSpring Bootconcurrency
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.

Backend DevelopmentJavaPerformance 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++Object PoolOptimization
1 likes · 44 min read
Boosting C++ Thread Pool Performance: Queue and Memory Optimizations
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.

JavaProfilingSpring
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.

Heap DumpJVMJava
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.

JavaThreadPoolExecutorbest practices
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.

Springconcurrencythread pool
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 CleanupSpring Bootasync
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.

JavaSpringdatabase
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 propagationInheritableThreadLocalJava
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.

Cluster healthData synchronizationElasticsearch
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.

Backend DevelopmentMessage 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.

AsynchronousCallableDeferredResult
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.

JavaMicroservicesasync
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.

Javaasyncspringboot
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 NIONon-blocking IOSelector
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.

JavaOutOfMemoryErrorThreadLocal
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.

IOCPWindowsasynchronous I/O
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.

Backend DevelopmentJavaSleuth
0 likes · 4 min read
Using Traceable Thread Pools in Spring Cloud to Preserve Trace Context
Top Architect
Top Architect
Feb 25, 2025 · Backend Development

Understanding Tomcat Configuration and Thread Pool Parameters in Spring Boot 2.7.10

This article explains the default Tomcat settings in Spring Boot 2.7.10, details core parameters such as connection queue length, max connections, thread pool sizes, keep-alive and timeout options, and demonstrates how to inspect and test these configurations with code examples and command-line tools.

JavaSpring Bootbackend configuration
0 likes · 16 min read
Understanding Tomcat Configuration and Thread Pool Parameters in Spring Boot 2.7.10
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.

Backend DevelopmentDynamic ScalingJava concurrency
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.

EasyExcelExcel ImportSpring Boot
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.

EasyExcelExcel ImportJava
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.

Backend DevelopmentJavaSpring 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.

Rate Limiterbackendthread 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.

ConfigurationSpring Boottesting
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
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.

JavaSpring Bootdynamic-configuration
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.

Backend DevelopmentExecutorServiceJava
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.

AsyncConfigurationSpring Boot
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.

CPUExecutorServiceI/O
0 likes · 15 min read
How to Properly Configure ThreadPoolExecutor Parameters in Java
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.

Backend DevelopmentData persistenceError handling
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.

Backend DevelopmentData persistenceJava
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.

JavaJava concurrencyPerformance Optimization
0 likes · 12 min read
Java Thread Pool: Working Mechanism, States, and Rejection Policies
Architecture Digest
Architecture Digest
Jul 16, 2024 · Backend Development

Understanding SpringBoot @EnableScheduling Issues and Solutions with Thread Pools and Distributed Locks

This article explains how SpringBoot's default @EnableScheduling and @Scheduled annotations can cause execution delays and single‑threaded bottlenecks, demonstrates the root causes in the auto‑configured ThreadPoolTaskScheduler, and provides four practical solutions—including custom thread‑pool configuration, async execution, and Redisson‑based distributed locking—to achieve reliable, concurrent scheduled tasks in both monolithic and distributed environments.

Schedulingasyncdistributed-lock
0 likes · 15 min read
Understanding SpringBoot @EnableScheduling Issues and Solutions with Thread Pools and Distributed Locks
JD Tech
JD Tech
Jul 12, 2024 · Backend Development

Dynamic Thread Pool: Monitoring, Alerting, and Runtime Parameter Adjustment

The article explains the concept of a dynamic thread pool, identifies common pain points such as invisible runtime status, hard‑to‑trace rejections, and slow parameter tuning, and presents a comprehensive solution that includes monitoring, alerting, automatic stack dumping, and live parameter refresh for Java backend services.

JavaMonitoringdynamic-configuration
0 likes · 20 min read
Dynamic Thread Pool: Monitoring, Alerting, and Runtime Parameter Adjustment
JD Retail Technology
JD Retail Technology
Jul 5, 2024 · Backend Development

Dynamic Thread Pool: Monitoring, Alerting, and Runtime Parameter Adjustment

The article explains the concept of dynamic thread pools, analyzes common pain points such as invisible runtime status, hard‑to‑locate rejections, and slow parameter tuning, and presents a comprehensive solution that includes monitoring, alerting, automatic stack tracing, and on‑the‑fly parameter refresh using Java code.

JavaMonitoringdynamic-configuration
0 likes · 19 min read
Dynamic Thread Pool: Monitoring, Alerting, and Runtime Parameter Adjustment
macrozheng
macrozheng
Jul 2, 2024 · Backend Development

How to Speed Up Excel-to-Database Imports with Async and Thread Pool Tuning

Learn how to efficiently import large Excel files into a database using POI, JDBC, MyBatis, and Spring Boot, with step-by-step code examples, performance bottlenecks, and optimization techniques such as caching, asynchronous processing, multi-threaded batch inserts, and thread‑pool configuration for maximum throughput.

ExcelJavaSpring Boot
0 likes · 16 min read
How to Speed Up Excel-to-Database Imports with Async and Thread Pool Tuning
Code Ape Tech Column
Code Ape Tech Column
Jun 3, 2024 · Backend Development

Seven Common Spring Boot Performance Optimization Techniques

This article presents seven practical Spring Boot performance optimization methods—including asynchronous execution, increasing Tomcat connection limits, component scanning, switching to Undertow, buffered I/O, DeferredResult handling, and AsyncHandlerInterceptor usage—each illustrated with clear code examples and explanations.

DeferredResultSpring BootUndertow
0 likes · 11 min read
Seven Common Spring Boot Performance Optimization Techniques
Su San Talks Tech
Su San Talks Tech
May 14, 2024 · Backend Development

How We Fixed Repeated Kafka Message Backlog in a High‑Traffic Restaurant System

This article details a series of Kafka message backlog incidents in a busy restaurant ordering system, analyzes root causes such as consumer speed, database indexing, and sudden traffic spikes, and presents step‑by‑step optimizations—including batch queries, index tuning, data archiving, and thread‑pool adjustments—to restore real‑time performance.

Performance Optimizationkafkamysql
0 likes · 11 min read
How We Fixed Repeated Kafka Message Backlog in a High‑Traffic Restaurant System
Shepherd Advanced Notes
Shepherd Advanced Notes
May 9, 2024 · Backend Development

How Many Simultaneous Requests Can SpringBoot Handle?

The article explains that SpringBoot’s request capacity is governed by Tomcat’s thread pool and connection settings, derives the formula max‑connections + accept‑count, demonstrates it with a small‑scale experiment, and discusses related concurrency pitfalls in singleton beans.

concurrencyrequest-limitingspringboot
0 likes · 8 min read
How Many Simultaneous Requests Can SpringBoot Handle?
IT Services Circle
IT Services Circle
May 4, 2024 · Backend Development

Common Backend Interface Optimization Techniques and Practices

This article shares a collection of practical backend performance‑optimization ideas—including batch database operations, asynchronous processing, caching, pre‑fetching, pooling, event‑driven callbacks, parallel remote calls, lock granularity, file‑based temporary storage, index tuning, deep‑pagination strategies, code‑level refactoring, data compression, NoSQL alternatives, thread‑pool configuration, and machine‑level troubleshooting—to dramatically reduce API latency and improve system scalability.

Asynchronousbackendthread pool
0 likes · 16 min read
Common Backend Interface Optimization Techniques and Practices
Architect
Architect
Mar 27, 2024 · Backend Development

Mastering Graceful Shutdown: Zero‑Downtime Deployments for Java Microservices

This article explains how to achieve zero‑downtime releases for Java applications by using JVM shutdown hooks, Spring context events, and service‑registry tricks for both monolithic and microservice architectures, with concrete code samples, configuration details, and Kubernetes probes to ensure seamless online upgrades.

Graceful ShutdownJavaMicroservices
0 likes · 29 min read
Mastering Graceful Shutdown: Zero‑Downtime Deployments for Java Microservices
Huolala Tech
Huolala Tech
Mar 21, 2024 · Backend Development

How a Faulty Lazy-Loading Design Caused Thread‑Pool Exhaustion and How to Fix It

A production incident where a poorly implemented lazy‑loading mechanism for KMSClient caused repeated initialization, blocking threads, exhausting the shared thread pool, and triggering RejectedExecutionException alerts, was investigated step‑by‑step, leading to a concrete code fix, improved monitoring, and better thread‑pool isolation.

JavaKMS clientbackend debugging
0 likes · 16 min read
How a Faulty Lazy-Loading Design Caused Thread‑Pool Exhaustion and How to Fix It
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Mar 15, 2024 · Backend Development

How to Dynamically Adjust Thread Pool Size with Nacos in Java

Learn how to integrate Nacos as a dynamic configuration center to modify Java thread pool sizes at runtime, covering dependency setup, initial Nacos configuration, custom listener implementation, thread pool usage, testing, and the benefits of adaptive scaling for production systems.

Backend DevelopmentJavadynamic-configuration
0 likes · 7 min read
How to Dynamically Adjust Thread Pool Size with Nacos in Java
Java Architect Essentials
Java Architect Essentials
Feb 29, 2024 · Backend Development

Building a Real‑Time Chat System with Netty, SpringBoot, and JavaFX

This article walks through the design and implementation of a three‑tier instant‑messaging platform—including a Netty‑based chat server, a JavaFX client, and a SpringBoot web admin console—covering architecture, protocol design, database schema, key Netty handlers, threading, and authentication details.

Database DesignInstant MessagingJavaFX
0 likes · 30 min read
Building a Real‑Time Chat System with Netty, SpringBoot, and JavaFX
Code Ape Tech Column
Code Ape Tech Column
Feb 4, 2024 · 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 using Nacos as a configuration center, covering Maven dependencies, YAML configuration files, Nacos data IDs, Java implementation with listeners, a REST controller for testing, and practical verification steps.

Backend DevelopmentJavaSpring Boot
0 likes · 11 min read
Implementing a Dynamic Thread Pool with Nacos in Spring Boot
Architect's Guide
Architect's Guide
Jan 27, 2024 · Backend Development

Optimizing Thread Pool Size for CPU‑Bound and I/O‑Bound Tasks in Java

This article explains the differences between CPU‑intensive and I/O‑intensive workloads, provides optimization strategies such as multithreading, caching, and load balancing, and presents Java code examples and formulas for calculating the optimal thread‑pool size based on core count, target CPU utilization, and blocking factors.

CPU BoundI/O BoundJava
0 likes · 12 min read
Optimizing Thread Pool Size for CPU‑Bound and I/O‑Bound Tasks in Java
Aikesheng Open Source Community
Aikesheng Open Source Community
Jan 22, 2024 · Databases

MySQL 8.3 New Features and Removed Functionality

Version 8.3 of MySQL introduces tagged GTID replication, a selectable JSON EXPLAIN format version, enhanced thread‑pool plugin information, changes to binlog transaction dependency tracking and new CMake options, while removing several C API functions, the FLUSH HOSTS statement, and outdated replication flags.

EXPLAINFeature RemovalGTID
0 likes · 6 min read
MySQL 8.3 New Features and Removed Functionality
JD Retail Technology
JD Retail Technology
Dec 25, 2023 · Backend Development

Investigation and Resolution of JSF Asynchronous Call Timeout Causing Interface Availability Degradation

This article documents the investigation of a JSF asynchronous call timeout that reduced interface availability, explains the async call mechanisms, analyzes the root cause in the callback thread pool, and presents short‑term and long‑term solutions to restore 100% availability.

AsynchronousBackend PerformanceCompletableFuture
0 likes · 12 min read
Investigation and Resolution of JSF Asynchronous Call Timeout Causing Interface Availability Degradation
JavaEdge
JavaEdge
Dec 10, 2023 · Backend Development

How to Size Java Thread Pools for Optimal Performance

This guide explains why thread pools are essential in Java, walks through factors such as CPU cores, I/O latency, and workload characteristics, and provides formulas and concrete code examples for calculating the ideal pool size for both CPU‑bound and I/O‑bound tasks.

CPU BoundI/O BoundJava
0 likes · 14 min read
How to Size Java Thread Pools for Optimal Performance
Architect
Architect
Nov 27, 2023 · Backend Development

Why 500 req/s Became 50 req/s: A Deep Dive into Spring Bean Creation Bottlenecks

A ToB system that seemed able to handle 500 requests per second stalled at 50 req/s due to hidden lock contention in prototype‑scoped Spring beans, slow SQL updates, excessive logging, and thread‑pool misconfiguration, prompting a step‑by‑step performance investigation and multiple optimizations.

JavaOptimizationSQL
0 likes · 16 min read
Why 500 req/s Became 50 req/s: A Deep Dive into Spring Bean Creation Bottlenecks