BestHub
Sign in
Tagged articles

Thread Pool

253 articles · Page 3 of 3
360 Quality & Efficiency
360 Quality & Efficiency
Oct 1, 2020 · Backend Development

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

This article demonstrates how to configure Python's logging module for console and file output, extend it with HTTPHandler for remote logging, and improve performance by using custom handlers, threading, thread pools, and asynchronous aiohttp calls to avoid blocking the main program.

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

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

This article uses a bank workflow analogy to compare blocking I/O (BIO), non‑blocking I/O (NIO), and asynchronous processing, showing how task decomposition and specialized threads dramatically increase system throughput while illustrating the trade‑offs of each approach.

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

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

This article explains the concept of pooling technology in Java, illustrating its benefits through real‑world analogies, detailing thread pools, memory pools, database connection pools, and HttpClient pools, and provides a performance comparison between raw threads and thread pools using a Java benchmark.

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

How to Calculate the Optimal Thread Pool Size for Java Applications

This article compares two popular formulas for estimating Java thread pool size, analyzes their equivalence, and provides practical guidelines for configuring thread counts in I/O‑bound and CPU‑bound workloads, including code examples and performance considerations.

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

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

This article provides a comprehensive analysis of Java's ThreadPoolExecutor, explaining its purpose, core attributes, state management using the ctl field, constructors, task submission mechanisms, worker thread creation, execution flow, task retrieval, shutdown procedures, and the intricate synchronization techniques that enable efficient thread reuse.

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

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

This article introduces a dynamic thread‑pool component for Spring Cloud that supports Cat monitoring, runtime core‑parameter adjustments, queue‑capacity and reject‑count alerts, and provides Nacos‑based configuration, code examples, and endpoint integration for operational visibility.

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

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

This article explains the definition of thread pools, why using Executors to create them is discouraged, details the ThreadPoolExecutor constructor and its parameters, compares different Executors factory methods, demonstrates OOM testing, and provides practical guidelines for defining safe thread‑pool parameters in Java.

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

Unlocking Java ThreadPoolExecutor: Design, Implementation, and Dynamic Tuning

This article explains the concept and benefits of Java thread pools, dives deep into the internal design and lifecycle of ThreadPoolExecutor with code examples, discusses real‑world usage scenarios and common configuration pitfalls, and presents a dynamic, monitorable thread‑pool solution to improve performance and reliability.

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

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

This article details a comprehensive experiment that evaluates MySQL's ability to sustain up to 100,000 simultaneous connections using Percona Server's thread‑pool plugin, sysbench clients, adjusted OS/network limits, and multiple IP addresses, presenting hardware specs, configuration steps, observed errors, performance metrics, and practical recommendations.

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

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

This article analyzes the performance bottlenecks of the 58 used‑car list service under high concurrency, breaks down data‑query and data‑transfer stages, and presents three optimization solutions—including query redesign, concurrent data conversion, and thread‑pool parameter tuning—that together reduce latency by over 80 ms and improve resource utilization.

Thread Poolconcurrencyhigh concurrency
0 likes · 9 min read
Optimizing High‑Concurrency List Service for 58 Used‑Car Platform: Data Query, Transformation, and Thread‑Pool Tuning
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.

Dynamic ConfigurationThread PoolThreadPoolExecutor
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.

Thread PoolThreadPoolExecutorexecutorservice
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 BoundThread Pool
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.

Thread Poolbackend developmentexecutorservice
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 RefactoringPerformance TestingThread Pool
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.

JVMLoad TestingRPC 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.

Java MultithreadingThread PoolThreadPoolExecutor
0 likes · 20 min read
Mastering Java Thread Pools: Creation, Configuration, and Best Practices
JD Retail Technology
JD Retail Technology
Dec 13, 2019 · Operations

Inside JD.com’s Product Detail Page: Architecture, Performance Analysis, and Optimization Strategies

This article examines the JD.com product detail page backend architecture, analyzes memory, thread, and CPU usage, and outlines a three‑stage optimization roadmap—including parallelization, JVM/Tomcat upgrades, thread‑pool tuning, and asynchronous refactoring—to handle massive traffic spikes.

CPU profilingOptimizationThread Pool
0 likes · 12 min read
Inside JD.com’s Product Detail Page: Architecture, Performance Analysis, and Optimization Strategies
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.

ExecutorsOOMThread Pool
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.jsThread Pool
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.

QPSThread Poolbackend
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.

Fault ToleranceIsolationThread Pool
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.

Thread Poolbackend developmentconcurrency
0 likes · 8 min read
Understanding Java Thread Pools: Origins, Benefits, Risks, Principles, Configuration, and Implementations
Big Data Technology & Architecture
Big Data Technology & Architecture
Feb 14, 2019 · Backend Development

Java Multithreading: Concepts, Creation Methods, Lifecycle, and Termination Techniques

This article offers a thorough tutorial on Java multithreading, explaining processes versus threads, thread creation approaches, lifecycle states, priority handling, and various safe and unsafe ways to stop threads, complete with practical code examples and best‑practice warnings.

Thread LifecycleThread PoolThread Termination
0 likes · 17 min read
Java Multithreading: Concepts, Creation Methods, Lifecycle, and Termination Techniques
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.

Thread PoolThreadPoolExecutorbackend development
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.

DisposableBeanLinux signalsSpring Boot
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.

Cloud DatabaseMySQLRocksDB
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.

MicroservicesReactiveThread Pool
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++Hash TableMemory Optimization
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.

MySQLThread Pooldatabase_configuration
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.

ElasticsearchRefresh IntervalSegment Merging
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.

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

InterviewThread Pooljava-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.

Java Util ConcurrentThread Poolblockingqueue
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 OptimizationThread Poolcaching
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.

Database DeadlockThread Poolbackend development
0 likes · 11 min read
How to Fix Common Java Backend Performance Pitfalls: Deadlocks, Thread Pools, and Logging
dbaplus Community
dbaplus Community
Jul 21, 2016 · Backend Development

Designing a Scalable Asynchronous Batch Processing Framework for Massive User Data

This article presents a detailed design and implementation of an asynchronous, parallel batch processing framework that tackles massive user data handling challenges by sharding databases, leveraging async HLR commands, configurable thread pools, and JMX monitoring to achieve high performance and reliability.

AsynchronousThread Poolbackend
0 likes · 16 min read
Designing a Scalable Asynchronous Batch Processing Framework for Massive User Data
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.

Thread Poollogging
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