BestHub
Sign in
Tagged articles

Thread Pool

262 articles · Page 2 of 3
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.

KafkaMySQLPerformance Optimization
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.

ConcurrencySpringBootThread Pool
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.

BackendThread Poolasynchronous
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.

EurekaGraceful ShutdownJava
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.

ConcurrencyJavaKMS client
0 likes · 16 min read
How a Faulty Lazy-Loading Design Caused Thread‑Pool Exhaustion and How to Fix It
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.

JavaFXNettyShiro Authentication
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.

JavaNacosSpring 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 BoundConcurrencyI/O Bound
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.

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

JavaLoad TestingOptimization
0 likes · 16 min read
Why 500 req/s Became 50 req/s: A Deep Dive into Spring Bean Creation Bottlenecks
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.

@AsyncSpring BootThread Pool
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.

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

ConcurrencyGarbage CollectionJava
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 Pool
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.

Asynchronous ProgrammingCompletableFutureConcurrency
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.

CPU utilizationJavaThread Pool
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.

ProactorReactorThread Pool
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.

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

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

Embedded ServerSpring BootThread Pool
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.

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

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

InterceptorMDCSpring Boot
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 concurrencyThread Pool
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 ProgrammingLinuxThread Pool
0 likes · 21 min read
Mastering POSIX Threads: From User Threads to Thread Pools in Linux
Architect Practice
Architect Practice
Feb 16, 2023 · Backend Development

Inside XXL-JOB: A Deep Dive into Its Distributed Scheduling Architecture

This article walks through XXL-JOB’s architecture, module layout, initialization of admin and executor components, thread‑pool strategies, registry and monitoring threads, job‑failure handling, time‑wheel scheduling, and the detailed Java code that powers the distributed task scheduler.

JavaThread PoolXXL-JOB
0 likes · 21 min read
Inside XXL-JOB: A Deep Dive into Its Distributed Scheduling Architecture
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.

NacosSpring BootThread Pool
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.

Thread Poolasynchronous
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.

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

Batch ProcessingHigh ConcurrencyThread Pool
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.

BackendResource IsolationThread Pool
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.

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

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

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

AOPDesign PatternJava
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.

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

@AsyncC++Concurrency
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.

BackendBatch ProcessingJava
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.

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

EurekaThread Poolheartbeat
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.

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

Thread Poolmicroservicesride-hailing
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.

JavaKafkaThread Pool
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.

BackendCachingJava
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 BootSpring Cloud
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.

ConcurrencyGMP modelGo
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.

JavaThread Poolconnection pool
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.

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

JavaThread Poolcode quality
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.

CompletableFutureJDK8Java
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 HandlingMySQLPercona
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.

Rate LimitingThread Poolinterview
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.

@AsyncConcurrencyJava
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.

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

JavaThread PoolThreadPoolExecutor
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.

PollingRxJavaThread Pool
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.

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

Circuit BreakingDubboPerformance 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.

Node.jsThread Poolasynchronous 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.

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

ConcurrencyJavaMemory Leak
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.

ConcurrencyJavaThread Pool
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.

ConcurrencyParallelismThread Pool
0 likes · 11 min read
Effective Python Parallelism with Thread Pools and the map() Function