BestHub
Sign in
Tagged articles

thread pool

241 articles · Page 3 of 3
Qunar Tech Salon
Qunar Tech Salon
Apr 15, 2020 · Backend Development

Deep Dive into Java ThreadPoolExecutor: Design, Implementation, and Dynamic Configuration

This article explains the concept, design, and internal implementation of Java's ThreadPoolExecutor, discusses common thread‑pool problems, presents dynamic configuration solutions, and provides practical usage scenarios and code examples to help developers efficiently manage concurrency in backend applications.

JavaThreadPoolExecutorconcurrency
0 likes · 27 min read
Deep Dive into Java ThreadPoolExecutor: Design, Implementation, and Dynamic Configuration
Java Captain
Java Captain
Apr 14, 2020 · Backend Development

Deep Dive into the Implementation of Java's ThreadPoolExecutor

This article provides a comprehensive analysis of Java's ThreadPoolExecutor source code, explaining its design, core attributes, constructors, task submission mechanisms, worker thread creation, thread‑reuse logic, and shutdown procedures, while illustrating each concept with detailed code examples and diagrams.

ExecutorServiceJavaThreadPoolExecutor
0 likes · 31 min read
Deep Dive into the Implementation of Java's ThreadPoolExecutor
Programmer DD
Programmer DD
Apr 10, 2020 · Fundamentals

When and How to Use Multithreading: Choosing the Right Thread Count

This article explains why multithreading remains essential, distinguishes CPU‑bound and I/O‑bound scenarios, provides formulas for calculating the optimal number of threads, discusses interview questions, and highlights practical considerations such as thread pools and synchronization.

CPU BoundI/O Boundmultithreading
0 likes · 13 min read
When and How to Use Multithreading: Choosing the Right Thread Count
Xiaokun's Architecture Exploration Notes
Xiaokun's Architecture Exploration Notes
Feb 18, 2020 · Backend Development

Mastering Java Thread Pools: Why They Matter and How They Work

This article explains the purpose, benefits, core APIs, implementation classes, execution flow, state management, and monitoring methods of Java thread pools, providing detailed code examples and diagrams to help developers understand and effectively use thread pooling in high‑concurrency applications.

Backend DevelopmentExecutorServiceJava
0 likes · 16 min read
Mastering Java Thread Pools: Why They Matter and How They Work
FunTester
FunTester
Feb 3, 2020 · Backend Development

Enhancements to Marking, Recording, and Thread Initialization in a Performance Testing Framework

This article details recent updates to a performance testing framework, including moving the mark feature into ThreadBase, changing method signatures, introducing two virtual thread limit classes for count‑based and time‑based execution, optimizing after() handling, and abandoning deep‑copy cloning for thread objects.

Code RefactoringJavamultithreading
0 likes · 10 min read
Enhancements to Marking, Recording, and Thread Initialization in a Performance Testing Framework
JD Retail Technology
JD Retail Technology
Jan 7, 2020 · Backend Development

Performance Optimization Practices for the Tongtian Tower Backend System

This article summarizes the Tongtian Tower backend performance optimization experience, detailing background, achieved improvements of 10‑30%, optimization principles, testing methods, metric analysis, and concrete strategies such as RPC scheduling, JVM tuning, logging, thread‑pool and code refinements to enhance latency and throughput.

JVMPerformance OptimizationRPC scheduling
0 likes · 12 min read
Performance Optimization Practices for the Tongtian Tower Backend System
Senior Brother's Insights
Senior Brother's Insights
Dec 16, 2019 · Backend Development

Mastering Java Thread Pools: Creation, Configuration, and Best Practices

This comprehensive guide explains Java thread pool fundamentals, creation methods, core parameters, rejection policies, execution flow, common work queues, and shutdown techniques, while providing interview questions, source‑code analysis, and practical code examples for robust concurrent programming.

ExecutorServiceJavaJava Multithreading
0 likes · 20 min read
Mastering Java Thread Pools: Creation, Configuration, and Best Practices
Programmer DD
Programmer DD
Nov 28, 2019 · Backend Development

Why You Should Avoid Executors for Thread Pools and Use ThreadPoolExecutor Directly

This article explains the definition of Java thread pools, why creating them via Executors is discouraged, details the ThreadPoolExecutor constructor and parameters, compares different Executors factory methods, demonstrates OOM risks with tests, and offers guidelines for configuring thread pool size and rejection policies.

ExecutorsJavaOOM
0 likes · 12 min read
Why You Should Avoid Executors for Thread Pools and Use ThreadPoolExecutor Directly
System Architect Go
System Architect Go
Sep 24, 2019 · Backend Development

Do CPU‑Intensive Tasks Block Node.js? An Experimental Study of libuv Thread Pool

An experiment demonstrates that CPU‑intensive encryption tasks do not block Node.js when the number of concurrent tasks does not exceed libuv’s default four‑thread pool, but adding a fifth task causes blocking, illustrating how libuv’s thread pool size and environment variable UV_THREADPOOL_SIZE affect concurrency.

CPU-intensiveNode.jslibuv
0 likes · 3 min read
Do CPU‑Intensive Tasks Block Node.js? An Experimental Study of libuv Thread Pool
Java Backend Technology
Java Backend Technology
May 25, 2019 · Backend Development

How to Size Thread Pools for Better CPU Utilization and QPS

This article explains why simply increasing thread‑pool size often fails, describes how CPU, network and disk I/O affect request handling, introduces the concept of context switching, and provides practical formulas and guidelines for calculating the optimal number of threads in a Java backend service.

JavaQPSbackend
0 likes · 9 min read
How to Size Thread Pools for Better CPU Utilization and QPS
dbaplus Community
dbaplus Community
May 25, 2019 · Backend Development

Mastering Thread‑Pool Isolation: Prevent Cascading Failures in Java Services

This article explains the concept of fault tolerance in software architecture, illustrates why thread‑pool isolation is essential for preventing cascading failures, and provides concrete Java implementations—including code examples, pros and cons, and practical guidance for applying the technique in real‑world backend systems.

Javabackendfault tolerance
0 likes · 10 min read
Mastering Thread‑Pool Isolation: Prevent Cascading Failures in Java Services
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Mar 14, 2019 · Backend Development

Understanding Java Thread Pools: Origins, Benefits, Risks, Principles, Configuration, and Implementations

This article explains the origin of Java thread pools, outlines their advantages and potential risks such as deadlocks and resource exhaustion, describes their internal states and processing flow, provides guidance on sizing for CPU‑ or I/O‑bound tasks, and reviews the four common thread‑pool implementations.

Backend DevelopmentJavaRisk Management
0 likes · 8 min read
Understanding Java Thread Pools: Origins, Benefits, Risks, Principles, Configuration, and Implementations
Programmer DD
Programmer DD
Oct 16, 2018 · Backend Development

Deep Dive into ThreadPoolExecutor: Uncover How Java Manages Thread Pools

This article provides a comprehensive analysis of Java's ThreadPoolExecutor source code, covering class relationships, core interfaces, abstract implementations, internal fields, constructors, the Worker class, and detailed walkthroughs of key methods such as execute, addWorker, runWorker, getTask, processWorkerExit, tryTerminate, and idle thread interruption, plus monitoring techniques.

Backend DevelopmentExecutorServiceJava
0 likes · 19 min read
Deep Dive into ThreadPoolExecutor: Uncover How Java Manages Thread Pools
Programmer DD
Programmer DD
Sep 22, 2018 · Backend Development

Why kill -9 vs kill -15? Mastering Graceful Shutdown in Spring Boot

This article explains the difference between kill -9 and kill -15 signals, how Spring Boot processes the TERM signal, and provides practical code examples for implementing graceful shutdown, including shutdown hooks, DisposableBean, and proper thread‑pool termination strategies.

DisposableBeanGraceful ShutdownJava
0 likes · 17 min read
Why kill -9 vs kill -15? Mastering Graceful Shutdown in Spring Boot
Tencent Cloud Developer
Tencent Cloud Developer
May 25, 2018 · Databases

TXSQL: The Cloud‑Era Database Kernel – Overview, Design, and Future Directions

TXSQL is Tencent Cloud’s MySQL‑based kernel, engineered to handle massive scale, improve stability, performance, and security for diverse industries, featuring optimized redo‑logs, thread‑pool handling, encryption, audit plugins, and parallel replication, with a rigorous release process and future plans for engine‑level batch computation and RocksDB integration.

Performance OptimizationRocksDBTXSQL
0 likes · 10 min read
TXSQL: The Cloud‑Era Database Kernel – Overview, Design, and Future Directions
Huawei Cloud Developer Alliance
Huawei Cloud Developer Alliance
May 14, 2018 · Backend Development

Optimizing ServiceComb Communication: Reactive vs Sync Thread Models

This article explains how ServiceComb builds on Vert.x to support both reactive and synchronous communication modes, details the thread models for single and multiple connections, presents performance improvements through CAS queues and multi‑connection setups, and outlines flexible thread‑pool strategies for microservice providers and consumers.

MicroservicesReactiveperformance
0 likes · 14 min read
Optimizing ServiceComb Communication: Reactive vs Sync Thread Models
dbaplus Community
dbaplus Community
Mar 26, 2018 · Databases

Mastering MySQL Thread Pool: Configuration, Pitfalls, and Performance Tuning

This article explains why MySQL thread pool is essential for high‑concurrency workloads, details its architecture and key parameters, provides step‑by‑step configuration examples, and shares real‑world troubleshooting cases such as memory leaks and connection‑timeout issues, along with practical solutions.

Configurationmysqlthread pool
0 likes · 16 min read
Mastering MySQL Thread Pool: Configuration, Pitfalls, and Performance Tuning
Tencent Cloud Developer
Tencent Cloud Developer
Mar 21, 2018 · Databases

Understanding MySQL Thread Pool: Architecture, Configuration, and Common Issues

The article explains MySQL’s thread‑pool technology—its motivation, architecture of listener, worker, timer threads and priority queues, key configuration variables, how to enable it, and common pitfalls such as memory leaks, monitoring timeouts, and group‑level saturation, offering practical guidance for DBAs.

ConfigurationDatabase Performancemysql
0 likes · 17 min read
Understanding MySQL Thread Pool: Architecture, Configuration, and Common Issues
Beike Product & Technology
Beike Product & Technology
Feb 7, 2018 · Backend Development

High‑Performance Challenge: Optimizing a C‑Based User Information Service for Tens of Millions of Records

This article recounts a 2017 internal high‑performance competition where a C server handling a 40 million‑row user‑info dataset was progressively optimized through data compression, custom hash tables, memory layout redesign, and a thread‑pool model, ultimately achieving a four‑fold throughput increase.

C#Memory optimizationdata compression
0 likes · 13 min read
High‑Performance Challenge: Optimizing a C‑Based User Information Service for Tens of Millions of Records
ITPUB
ITPUB
Dec 21, 2017 · Databases

Why MySQL Connections Stall and How Adjusting thread_cache_size Fixes It

The article explains why Percona‑MySQL 5.6 experiences occasional high‑latency connections, analyzes the role of thread pools and thread cache settings, and shows step‑by‑step how increasing thread_cache_size to match active connections eliminates the slowdown.

database_configurationmysqlperformance_tuning
0 likes · 6 min read
Why MySQL Connections Stall and How Adjusting thread_cache_size Fixes It
vivo Internet Technology
vivo Internet Technology
Oct 14, 2017 · Databases

Elasticsearch Index Performance Optimization (Part 2)

To maximize Elasticsearch bulk-indexing speed, temporarily disable refreshes and replicas, tune merge throttling and scheduler threads, enlarge translog and index buffer thresholds, and adjust indexing and bulk thread-pool sizes, then restore defaults after the load completes.

ElasticsearchPerformance TuningRefresh Interval
0 likes · 13 min read
Elasticsearch Index Performance Optimization (Part 2)
Qunar Tech Salon
Qunar Tech Salon
Jun 14, 2017 · Fundamentals

In‑Depth Analysis of Java ThreadPoolExecutor and Thread‑Pool Mechanisms

This article revisits Java thread pools, explains the concept of pooling, details the structure and parameters of ThreadPoolExecutor, describes its execution flow, rejection policies, hook methods, lifecycle states, and offers guidance on sizing and extending thread pools for real‑world applications.

JavaThreadPoolExecutorthread pool
0 likes · 8 min read
In‑Depth Analysis of Java ThreadPoolExecutor and Thread‑Pool Mechanisms
ITPUB
ITPUB
Apr 29, 2017 · Backend Development

40 Essential Java Multithreading Interview Questions Explained

This article compiles and clarifies forty common Java multithreading interview questions, covering thread creation, synchronization mechanisms, thread pools, memory model, and practical debugging techniques to help developers deepen their understanding and prepare for technical interviews.

Synchronizationinterviewjava-memory-model
0 likes · 30 min read
40 Essential Java Multithreading Interview Questions Explained
ZhiKe AI
ZhiKe AI
Feb 22, 2017 · Fundamentals

Understanding Java’s java.util.concurrent Package and Thread Pools

This article introduces the java.util.concurrent package introduced since JDK 5, explains the five thread‑pool creation methods, demonstrates how to use Runnable and Callable, details BlockingQueue operations and implementations, and summarizes best practices for building robust, high‑concurrency Java applications.

BlockingQueueJavaconcurrency
0 likes · 10 min read
Understanding Java’s java.util.concurrent Package and Thread Pools
Taobao Frontend Technology
Taobao Frontend Technology
Dec 8, 2016 · Frontend Development

How HappyPack Supercharges Webpack Builds with Multi‑Process Parallelism

This article introduces HappyPack—a webpack plugin that speeds up builds by running loaders in parallel processes—covers its configuration, internal architecture including thread‑pool management, RPC handling, caching mechanisms, and provides detailed code examples to illustrate its integration and operation.

Build OptimizationCachinghappypack
0 likes · 18 min read
How HappyPack Supercharges Webpack Builds with Multi‑Process Parallelism
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Oct 24, 2016 · Backend Development

How to Fix Common Java Backend Performance Pitfalls: Deadlocks, Thread Pools, and Logging

This article examines typical Java backend performance problems such as database deadlocks, overly long transactions, thread‑pool misuse, and excessive logging, and provides concrete optimization strategies—including Redis distributed locks, short‑lived transactions, proper thread‑pool configuration, and disciplined log formatting—to dramatically improve throughput and stability.

Backend DevelopmentDatabase Deadlockthread pool
0 likes · 11 min read
How to Fix Common Java Backend Performance Pitfalls: Deadlocks, Thread Pools, and Logging
21CTO
21CTO
Jun 16, 2016 · Backend Development

How We Transformed a Legacy System’s Performance: Real‑World Code‑Level Optimizations

This article walks through a real‑world project's performance evolution, detailing server specs, a litany of scalability and reliability problems, and concrete code‑level solutions such as database deadlock mitigation, transaction shortening, thread‑pool redesign, and logging improvements.

JavaLoggingPerformance Optimization
0 likes · 11 min read
How We Transformed a Legacy System’s Performance: Real‑World Code‑Level Optimizations
Architect
Architect
Jun 13, 2016 · Backend Development

Performance Optimization Journey of a No‑Card Payment System: Database Deadlock, Transaction Length, Thread‑Pool, and Logging Improvements

This article examines the performance bottlenecks of a no‑card payment platform—including database deadlocks, overly long transactions, CPU saturation, unbounded thread pools, and excessive logging—and presents concrete backend‑level refactorings, configuration changes, and code examples that dramatically improve scalability and reliability.

Loggingthread pool
0 likes · 11 min read
Performance Optimization Journey of a No‑Card Payment System: Database Deadlock, Transaction Length, Thread‑Pool, and Logging Improvements
DevOps
DevOps
Apr 3, 2016 · Fundamentals

The Life of a Thread: A Narrative on Thread Pools, Locks, and Deadlocks

A metaphorical story follows a newly created thread as it learns about extracting request parameters, performing login, handling CPU scheduling, using caches, encountering deadlocks, and ultimately witnessing a system reboot, illustrating core concepts of multithreading, concurrency control, and thread‑pool lifecycle.

CPU schedulingDeadlockLocks
0 likes · 12 min read
The Life of a Thread: A Narrative on Thread Pools, Locks, and Deadlocks