BestHub
Sign in
Tagged articles
358 articles
Page 2 of 4
Selected Java Interview Questions
Selected Java Interview Questions
Jul 7, 2024 · Backend Development

Understanding Thread Pool Shutdown and Garbage Collection in Java

This article explains why a Java thread pool with many waiting threads does not release resources, how calling shutdown or shutdownNow interrupts idle workers, how the ThreadPoolExecutor internals handle interruptions, and why proper shutdown is essential to allow both threads and the pool itself to be garbage‑collected.

ExecutorServiceGarbageCollectionJava
0 likes · 11 min read
Understanding Thread Pool Shutdown and Garbage Collection in Java
JD Tech
JD Tech
Jul 6, 2024 · Backend Development

Investigation of JSF Thread‑Pool Exhaustion During R2M Redis Upgrade

This article details a step‑by‑step investigation of a JSF thread‑pool exhaustion error that occurred when upgrading the Redis version of JD's internal R2M distributed cache, analyzing stack traces, lock contention, ForkJoinPool behavior, and the eventual remediation steps.

JSFJavaR2M
0 likes · 7 min read
Investigation of JSF Thread‑Pool Exhaustion During R2M Redis Upgrade
Architect
Architect
Jul 3, 2024 · Backend Development

How to Supercharge Java Backend Performance: Parallelism, Thread Pools, Caching, and More

This article walks through practical Java backend performance techniques—including parallel processing with CompletableFuture, fine‑tuned thread‑pool configuration, transaction scope minimization, cache‑line awareness, object‑pool usage, lock granularity, copy‑on‑write collections, and network payload reduction—backed by concrete code samples, benchmark results, and step‑by‑step analysis of trade‑offs and best practices.

JavaThreadPoolcaching
0 likes · 36 min read
How to Supercharge Java Backend Performance: Parallelism, Thread Pools, Caching, and More
Top Architect
Top Architect
Jun 24, 2024 · Backend Development

Understanding Tomcat Configuration and Thread Management in Spring Boot 2.7.10

This article explains the default Tomcat settings bundled with Spring Boot 2.7.10, details core parameters such as accept‑count, max‑connections, thread pool sizes, and timeouts, describes the internal Acceptor and Poller threads, provides configuration examples and testing results, and includes reference links.

JavaSpring BootThreadPool
0 likes · 18 min read
Understanding Tomcat Configuration and Thread Management in Spring Boot 2.7.10
Cognitive Technology Team
Cognitive Technology Team
Jun 23, 2024 · Backend Development

Customizing Thread Pools for Java parallelStream to Improve Performance and Isolation

This article explains how Java's parallelStream uses the shared ForkJoinPool, why developers may need to customize the thread pool for better performance and isolation, and provides two approaches—setting the system property and creating a dedicated ForkJoinPool—along with complete code examples and execution results.

ForkJoinPoolJavaParallelStream
0 likes · 4 min read
Customizing Thread Pools for Java parallelStream to Improve Performance and Isolation
Su San Talks Tech
Su San Talks Tech
Jun 22, 2024 · Backend Development

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

This article explains the common slow approach of reading Excel files with POI and inserting rows via JDBC, then presents three practical optimizations—caching data, using asynchronous multithreaded reads, and per‑file async processing—along with thread‑pool configuration tips and EasyExcel examples to dramatically reduce import time from minutes to seconds.

AsyncExcelJava
0 likes · 17 min read
How to Speed Up Excel-to-Database Imports with Async and Thread‑Pool Tuning in Java
Huolala Tech
Huolala Tech
Jun 20, 2024 · Backend Development

Why Our Core Service Crashed: Tomcat Thread Pool Bottlenecks & Custom Executor Pitfalls

On October 27, 2023, a sudden surge in request volume and downstream latency caused the bfe‑customer‑application‑query‑svc to exhaust its Tomcat thread pool, triggering health‑check failures and pod restarts; a deep dive revealed that an ill‑designed custom executor and unchecked thread‑waiting calls created a bottleneck that amplified the outage.

ExecutorIncidentAnalysisJava
0 likes · 36 min read
Why Our Core Service Crashed: Tomcat Thread Pool Bottlenecks & Custom Executor Pitfalls
Su San Talks Tech
Su San Talks Tech
Jun 14, 2024 · Backend Development

Master Java ThreadPoolExecutor: Interview Questions & Deep Dive

This article provides a comprehensive guide to Java thread pools, covering common interview questions, core parameters, execution flow, lock mechanisms, custom queue implementations, rejection policies, best practices, monitoring strategies, and dynamic tuning with DynamicTp, all illustrated with code examples and diagrams.

JUCJavaThreadPool
0 likes · 33 min read
Master Java ThreadPoolExecutor: Interview Questions & Deep Dive
Cognitive Technology Team
Cognitive Technology Team
Jun 10, 2024 · Backend Development

Gracefully Shutting Down a Thread Pool in Java

To gracefully shut down a Java thread pool, use ExecutorService's shutdown() to reject new tasks, awaitTermination() to wait for running tasks with optional timeout, handle exceptions, and optionally invoke shutdownNow() for forced termination, as illustrated by code examples from Dubbo3 and RocketMQ.

ExecutorServiceGracefulShutdownJava
0 likes · 4 min read
Gracefully Shutting Down a Thread Pool in Java
dbaplus Community
dbaplus Community
Jun 3, 2024 · Backend Development

Why Your ScheduledExecutorService Stops After an Exception—and How to Fix It

A mis‑handled exception in a ScheduledExecutorService can silently halt the entire scheduled thread pool, causing critical periodic jobs to stop; this article explains the underlying delay‑queue and thread‑pool mechanics, shows reproducible code, and provides practical safeguards to keep scheduled tasks alive.

DelayQueueJavaScheduledExecutorService
0 likes · 9 min read
Why Your ScheduledExecutorService Stops After an Exception—and How to Fix It
Top Architect
Top Architect
May 28, 2024 · Backend Development

Implementing Process Pooling in Java with GenericObjectPool

This article explains how Java developers can use thread pools and Apache Commons Pool2's GenericObjectPool to create a reusable process pool, covering the underlying concepts, required interfaces, Maven dependencies, configuration options, and practical code examples to improve performance.

GenericObjectPoolJavaPooling
0 likes · 11 min read
Implementing Process Pooling in Java with GenericObjectPool
Huolala Tech
Huolala Tech
May 16, 2024 · Backend Development

Debugging Java Outages: HikariCP Thread Pool, CPU Load & Connection Timeouts

After an Alibaba Cloud RDS host failure caused a HA switch, the bme‑trade‑order‑svc service experienced prolonged unavailability; this article dissects how thread‑pool saturation, HikariCP connection‑pool mechanics, and CPU load interplay, and outlines systematic investigations that pinpointed thread waiting, pod restarts, and CPU throttling as root causes.

HikariCPJavaKubernetes
0 likes · 44 min read
Debugging Java Outages: HikariCP Thread Pool, CPU Load & Connection Timeouts
FunTester
FunTester
May 6, 2024 · Backend Development

Building a Multi‑Priority Thread Pool with Java's PriorityBlockingQueue

This article explains how to solve Java thread‑pool priority problems by leveraging java.util.concurrent.PriorityBlockingQueue, details its thread‑safe and unbounded features, and provides a complete multi‑priority thread‑pool implementation with sample code and a test demonstrating correct task ordering.

JavaPriority SchedulingPriorityBlockingQueue
0 likes · 6 min read
Building a Multi‑Priority Thread Pool with Java's PriorityBlockingQueue
Su San Talks Tech
Su San Talks Tech
Apr 30, 2024 · Backend Development

Mastering Context Propagation in Thread Pools with TransmittableThreadLocal

This article explains why standard ThreadLocal mechanisms fail with thread pools, introduces the design of a custom solution using YesThreadLocal and YesRunnable, and then details how Alibaba's TransmittableThreadLocal (TTL) implements context capture, replay, and restoration for seamless asynchronous execution.

ContextPropagationJavaThreadLocal
0 likes · 12 min read
Mastering Context Propagation in Thread Pools with TransmittableThreadLocal
JD Tech
JD Tech
Apr 15, 2024 · Backend Development

How Java Thread Pools Handle Exceptions: execute vs submit

This article investigates how Java's java.util.concurrent.ExecutorService thread pools react to exceptions when tasks are submitted via execute versus submit, providing source‑code experiments, observed outcomes, and a detailed analysis of the underlying JDK implementation.

ExecutorServiceJavaThreadPool
0 likes · 8 min read
How Java Thread Pools Handle Exceptions: execute vs submit
IT Services Circle
IT Services Circle
Mar 23, 2024 · Backend Development

Java Backend Interview Guide: Redis, Thread Pools, Spring, Concurrency, and Core Java Concepts

This article compiles a comprehensive Java backend interview guide covering Redis fundamentals, thread creation methods, thread‑pool pitfalls, Spring ecosystem relationships, IoC/AOP principles, shallow vs deep copying, collection cloning, differences between interfaces and abstract classes, and string handling classes, providing concise explanations and code examples for each topic.

BackendJavaThreadPool
0 likes · 19 min read
Java Backend Interview Guide: Redis, Thread Pools, Spring, Concurrency, and Core Java Concepts
Architect's Guide
Architect's Guide
Mar 22, 2024 · Backend Development

Understanding ForkJoinPool: Principles, Implementation, and Performance Evaluation in Java

This article explains the Fork/Join model and Java's ForkJoinPool, covering divide‑and‑conquer theory, custom RecursiveTask examples, pool construction options, task submission methods, work‑stealing mechanics, commonPool pitfalls, and performance testing results to help developers decide when to use it.

DivideAndConquerForkJoinPoolJava
0 likes · 22 min read
Understanding ForkJoinPool: Principles, Implementation, and Performance Evaluation in Java
JD Retail Technology
JD Retail Technology
Mar 20, 2024 · Backend Development

Multithreaded Pagination Query with Java ThreadPoolExecutor: Principles, Parameters, and Usage

This article explains how using a Java thread pool for multithreaded pagination can dramatically speed up large‑scale data queries, outlines thread‑pool concepts and benefits, details ThreadPoolExecutor parameters and work‑queue options, and reviews common rejection policies and built‑in pool factories.

BackendJavaThreadPool
0 likes · 6 min read
Multithreaded Pagination Query with Java ThreadPoolExecutor: Principles, Parameters, and Usage
Architect
Architect
Feb 24, 2024 · Backend Development

Implementing a Dynamic Thread Pool with Nacos in Spring Cloud

This article demonstrates how to build a dynamically configurable thread pool in a Spring Cloud backend by using Nacos as a configuration center, covering dependency setup, YAML files, Java implementation, controller exposure, testing steps, and practical tips for runtime adjustments.

BackendDynamic ConfigurationJava
0 likes · 9 min read
Implementing a Dynamic Thread Pool with Nacos in Spring Cloud
DeWu Technology
DeWu Technology
Feb 23, 2024 · Backend Development

Understanding Thread Pool Exhaustion in Dubbo: Causes and Diagnosis

The article explains that Dubbo’s zero‑capacity SynchronousQueue causes a thread‑pool “EXHAUSTED” error when incoming requests outpace consumption, often triggered by slow DB queries, lock contention, or network jitter, and that JVM stop‑the‑world pauses fill the OS TCP receive buffer, creating a post‑pause traffic burst that overwhelms the pool, with diagnostics using safepoint statistics.

DubboJVMSTW
0 likes · 9 min read
Understanding Thread Pool Exhaustion in Dubbo: Causes and Diagnosis
macrozheng
macrozheng
Feb 22, 2024 · Backend Development

How Many Requests Can a Default SpringBoot App Handle? Inside Tomcat & Undertow Thread Pools

This article walks through an interview question about the maximum concurrent requests a default SpringBoot application can process, builds a minimal demo, examines Tomcat and Undertow thread‑pool configurations, and shows how container defaults and parameters like core size, max size, and queue length determine the real limit.

JavaSpringBootThreadPool
0 likes · 19 min read
How Many Requests Can a Default SpringBoot App Handle? Inside Tomcat & Undertow Thread Pools
Code Ape Tech Column
Code Ape Tech Column
Feb 20, 2024 · Backend Development

Understanding ForkJoinPool: Divide‑and‑Conquer, Task Splitting, and Performance in Java

This article explains the limitations of ThreadPoolExecutor, introduces the Fork/Join model and its divide‑and‑conquer algorithm, demonstrates custom RecursiveTask implementations with full source code, analyzes ForkJoinPool construction, task submission, work‑stealing, monitoring APIs, commonPool pitfalls, and performance evaluation, providing practical guidance for Java developers.

ForkJoinPoolJavaThreadPool
0 likes · 24 min read
Understanding ForkJoinPool: Divide‑and‑Conquer, Task Splitting, and Performance in Java
IT Services Circle
IT Services Circle
Feb 9, 2024 · Fundamentals

Interview Topics: URL Processing, TLS Handshake, TCP Handshake, Page Fault, TCP vs UDP, HTTP Differences, Thread Safety in C++, and Thread‑Pool Implementation

This article reviews common interview questions covering URL request processing, TLS handshake steps, the three‑way TCP handshake and four‑way termination, page‑fault handling, differences between TCP and UDP, HTTP/1.0 vs 1.1, thread‑safety mechanisms in C++, and a hands‑on example of building a thread pool.

C++HTTPNetworking
0 likes · 18 min read
Interview Topics: URL Processing, TLS Handshake, TCP Handshake, Page Fault, TCP vs UDP, HTTP Differences, Thread Safety in C++, and Thread‑Pool Implementation
Architect's Guide
Architect's Guide
Feb 9, 2024 · Backend Development

How to Capture Exceptions from Java ThreadPool Tasks: submit vs execute and Three Solutions

This article explains why exceptions from tasks submitted to a Java ThreadPool using submit are not printed, how execute shows them, and presents three practical approaches—try‑catch within the task, a custom Thread.setDefaultUncaughtExceptionHandler, and overriding afterExecute—to reliably obtain and handle those exceptions.

ExecutorServiceFutureJava
0 likes · 14 min read
How to Capture Exceptions from Java ThreadPool Tasks: submit vs execute and Three Solutions
Sohu Tech Products
Sohu Tech Products
Jan 24, 2024 · Mobile Development

Advanced Android Binder Interview Questions and Answers

This guide presents advanced Android Binder interview questions and concise answers, covering its architecture, cross‑process communication, relationship with AIDL, object lifecycle and death notifications, thread‑pool mechanics, performance tuning for large data transfers, and security measures, equipping engineers for confident interview performance.

AIDLAndroidBinder
0 likes · 15 min read
Advanced Android Binder Interview Questions and Answers
Alibaba Cloud Developer
Alibaba Cloud Developer
Jan 22, 2024 · Backend Development

Master Java Thread Scheduling, Pools, and Synchronization: A Complete Guide

This comprehensive article explains Java thread lifecycle, state transitions, blocking and wake‑up mechanisms, differences between wait and sleep, various ways to create threads, thread‑pool architecture and rejection policies, lock implementations including synchronized, ReentrantLock, optimistic CAS, as well as ThreadLocal, concurrent collections, immutability, and the Java Memory Model, providing practical code examples and optimization tips for robust multithreaded programming.

SynchronizationThreadPoolconcurrency
0 likes · 23 min read
Master Java Thread Scheduling, Pools, and Synchronization: A Complete Guide
Su San Talks Tech
Su San Talks Tech
Jan 22, 2024 · Backend Development

How to Supercharge Excel-to-Database Imports with Async and Thread‑Pool Tuning in Java

This article walks through the common slow Excel‑to‑DB import pattern, shows why it becomes a bottleneck, and presents three progressive optimizations—including caching, asynchronous multi‑threaded reading, and double‑async processing—along with detailed Spring @Async thread‑pool configuration and EasyExcel alternatives, all illustrated with complete Java code samples.

AsyncExcelJava
0 likes · 17 min read
How to Supercharge Excel-to-Database Imports with Async and Thread‑Pool Tuning in Java
IT Services Circle
IT Services Circle
Dec 29, 2023 · Backend Development

Bank Software Development Interview Guide: Java, MySQL, Thread Pools, HTTP, TCP/UDP, and Database Indexes

This article compiles common technical interview questions for bank software positions, covering Java fundamentals, MySQL storage engines and indexes, thread‑pool parameters, HTTP GET/POST differences, TCP vs UDP characteristics, session and cookie handling, Redis data types, and C++ memory management, providing concise explanations and examples for each topic.

C++DatabaseIndexHTTP
0 likes · 32 min read
Bank Software Development Interview Guide: Java, MySQL, Thread Pools, HTTP, TCP/UDP, and Database Indexes
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Dec 26, 2023 · Backend Development

Understanding Java Thread Pools: Creation, Execution Flow, Advantages, and Common Implementations

This article introduces Java thread pools, explaining their purpose, creation using ThreadPoolExecutor, execution flow, advantages such as resource reuse and management, common blocking queues, rejection policies, and provides multiple code examples of various pool types and a comprehensive monitoring example.

BlockingQueueExecutorServiceJava
0 likes · 11 min read
Understanding Java Thread Pools: Creation, Execution Flow, Advantages, and Common Implementations
Java Captain
Java Captain
Dec 19, 2023 · Fundamentals

An Introduction to Java Multithreading: Basics, Techniques, and Applications

This article introduces Java multithreading, covering core concepts such as thread lifecycle, creation via Thread subclass and Runnable, synchronization mechanisms, thread pools, and practical applications in web, Android, game, and big data development, helping readers fully grasp multithreaded programming in Java.

JavaSynchronizationThreadPool
0 likes · 4 min read
An Introduction to Java Multithreading: Basics, Techniques, and Applications
Selected Java Interview Questions
Selected Java Interview Questions
Nov 18, 2023 · Backend Development

A Comprehensive Guide to Java CompletableFuture: Replacing Future and CountDownLatch with Elegant Asynchronous Patterns

This article explains Java's Future and CompletableFuture APIs, demonstrates how to replace blocking Future.get() and CountDownLatch patterns with CompletableFuture, shows creation methods, result retrieval options, callback chains, exception handling, task composition techniques, and provides best‑practice recommendations for thread‑pool usage.

AsynchronousCompletableFutureFuture
0 likes · 22 min read
A Comprehensive Guide to Java CompletableFuture: Replacing Future and CountDownLatch with Elegant Asynchronous Patterns
Sanyou's Java Diary
Sanyou's Java Diary
Nov 2, 2023 · Backend Development

How Many Requests Can a Default SpringBoot App Handle? Uncover Tomcat & Undertow Limits

This article explores how many concurrent requests a SpringBoot application can process with default settings, demonstrating a hands‑on demo, analyzing Tomcat’s thread‑pool defaults, comparing Undertow behavior, and revealing how configuration parameters like core threads, max threads, queue size, and connection limits affect throughput.

SpringBootThreadPoolTomcat
0 likes · 18 min read
How Many Requests Can a Default SpringBoot App Handle? Uncover Tomcat & Undertow Limits
TAL Education Technology
TAL Education Technology
Nov 2, 2023 · Backend Development

Java CompletableFuture: Creation, Asynchronous Callbacks, Composition, and Thread‑Pool Configuration

This article explains Java's CompletableFuture utility introduced in Java 8, covering its creation methods, asynchronous callback functions, exception handling, task composition, combination operators, underlying implementation details, and best practices for configuring thread pools to achieve efficient concurrent execution.

AsyncCompletableFutureJava
0 likes · 32 min read
Java CompletableFuture: Creation, Asynchronous Callbacks, Composition, and Thread‑Pool Configuration
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Oct 23, 2023 · Backend Development

Boost Spring Performance: AOP Logging, Caching, Thread Pools & DB Optimizations

This article presents practical Spring performance optimization techniques—including AOP‑based logging, second‑level caching with @Cacheable, reducing database queries via fetch strategies, employing thread‑pool executors, and general database query tuning—to improve application speed and resource efficiency.

ThreadPoolaopcaching
0 likes · 9 min read
Boost Spring Performance: AOP Logging, Caching, Thread Pools & DB Optimizations
Code Ape Tech Column
Code Ape Tech Column
Oct 20, 2023 · Backend Development

Handling Exceptions in Java ThreadPool: submit vs execute and Practical Solutions

This article explains why exceptions submitted to a Java ThreadPool via submit are not printed, how to retrieve them using Future.get(), and presents three practical solutions—including try‑catch, Thread.setDefaultUncaughtExceptionHandler, and overriding afterExecute—to reliably capture and process thread pool exceptions.

ExecutorServiceJavaThreadPool
0 likes · 15 min read
Handling Exceptions in Java ThreadPool: submit vs execute and Practical Solutions
vivo Internet Technology
vivo Internet Technology
Oct 11, 2023 · Backend Development

Investigation of Dubbo Thread‑Pool Exhaustion Caused by Redis Cluster Pipeline Deadlock

The article details how a Dubbo thread‑pool exhaustion incident was traced to a deadlock in Redis Cluster pipeline usage, caused by Jedis pools lacking a borrow timeout, which let threads block indefinitely while holding cross‑node connections, and recommends configuring maxWaitMillis or enlarging the pool to prevent recurrence.

DubboJavaJedis
0 likes · 14 min read
Investigation of Dubbo Thread‑Pool Exhaustion Caused by Redis Cluster Pipeline Deadlock
Architect
Architect
Sep 25, 2023 · Backend Development

Using @Async in Spring: Default Thread Pools, Custom Thread Pools, and Best Practices

Spring's @Async annotation enables asynchronous method execution, but its default SimpleAsyncTaskExecutor creates a new thread per task, leading to resource issues; the article explains built‑in executors, their drawbacks, and how to implement custom thread pools via AsyncConfigurer, AsyncConfigurerSupport, or a custom TaskExecutor for better control.

AsyncJavaThreadPool
0 likes · 8 min read
Using @Async in Spring: Default Thread Pools, Custom Thread Pools, and Best Practices
政采云技术
政采云技术
Sep 13, 2023 · Backend Development

Understanding Java Threads and Thread Pools

This article explains the concept of threads in Java, how to create them, the purpose and benefits of thread pools, the inheritance hierarchy of Java's Executor framework, key parameters of ThreadPoolExecutor, rejection policies, pool states, and the underlying working mechanism, supplemented with code examples.

ExecutorJavaRejectionPolicy
0 likes · 15 min read
Understanding Java Threads and Thread Pools
ZhongAn Tech Team
ZhongAn Tech Team
Sep 1, 2023 · Backend Development

Investigation and Fix of OpenTelemetry ThreadPool Trace Propagation Bug in Non‑Capturing Lambda Scenarios

This article analyzes a sporadic loss of trace information when using OpenTelemetry’s non‑capturing lambda tasks in a Java ThreadPoolExecutor, explains the underlying cause related to Runnable reuse and lambda caching, and presents the community‑driven patches that correctly propagate context across threads.

BugFixJavaLambda
0 likes · 10 min read
Investigation and Fix of OpenTelemetry ThreadPool Trace Propagation Bug in Non‑Capturing Lambda Scenarios
Java Interview Crash Guide
Java Interview Crash Guide
Aug 25, 2023 · Backend Development

Boost SpringBoot API Speed with Asynchronous Methods

This article explains why asynchronous methods improve response speed in SpringBoot, demonstrates how to enable @Async, implement service and controller code, configure custom thread pools, handle exceptions, and retrieve results, showing measurable performance gains through non‑blocking execution.

AsyncBackendJava
0 likes · 9 min read
Boost SpringBoot API Speed with Asynchronous Methods
macrozheng
macrozheng
Aug 25, 2023 · Backend Development

How Many Requests Can a Default SpringBoot App Handle? Uncover Tomcat & Undertow Thread Pool Secrets

This article explores the interview question of how many concurrent requests a SpringBoot project can process by building a minimal demo, measuring Tomcat and Undertow thread pool limits, analyzing default configurations, and showing how container settings and annotations like @Async affect the actual request capacity.

SpringBootThreadPoolTomcat
0 likes · 19 min read
How Many Requests Can a Default SpringBoot App Handle? Uncover Tomcat & Undertow Thread Pool Secrets
MaGe Linux Operations
MaGe Linux Operations
Aug 21, 2023 · Backend Development

Why Your Java ThreadPool Won’t Release Threads – The Hidden Power of shutdown()

This article explores why a Java thread pool can retain hundreds of waiting threads, explains how the shutdown and shutdownNow methods trigger thread interruption, details the internal worker lifecycle that leads to garbage collection, and provides practical code demos to ensure proper resource cleanup.

ExecutorServiceGarbageCollectionJava
0 likes · 14 min read
Why Your Java ThreadPool Won’t Release Threads – The Hidden Power of shutdown()
FunTester
FunTester
Aug 21, 2023 · Backend Development

Understanding Web3j Asynchronous Calls and JVM Exit Issues

The article analyzes why using Web3j's sendAsync() method can prevent the JVM from terminating, examines the underlying thread‑pool implementation in org.web3j.utils.Async, and offers debugging steps and possible work‑arounds for developers.

AsynchronousJVMJava
0 likes · 7 min read
Understanding Web3j Asynchronous Calls and JVM Exit Issues
Architect's Tech Stack
Architect's Tech Stack
Aug 13, 2023 · Backend Development

Handling Exceptions in Java Thread Pools: submit vs execute and Custom Strategies

This article explains why tasks submitted with ExecutorService.submit silently swallow exceptions, how ExecutorService.execute prints them, and presents three practical solutions—including try‑catch, a custom ThreadFactory with UncaughtExceptionHandler, and overriding afterExecute—to reliably capture and process thread‑pool errors in Java.

ExecutorServiceJavaThreadPool
0 likes · 14 min read
Handling Exceptions in Java Thread Pools: submit vs execute and Custom Strategies
Top Architect
Top Architect
Aug 7, 2023 · Backend Development

Best Practices and Pitfalls of Using Thread Pools in Java

This article explains how to correctly declare, monitor, and configure Java thread pools, recommends naming conventions, discusses CPU vs I/O workload sizing, highlights common pitfalls such as deadlocks and ThreadLocal misuse, and introduces dynamic pool‑adjustment techniques used by large tech companies.

JavaThreadPoolconcurrency
0 likes · 16 min read
Best Practices and Pitfalls of Using Thread Pools in Java
Test Development Learning Exchange
Test Development Learning Exchange
Aug 3, 2023 · Fundamentals

10 Practical Scenarios Using ThreadPoolExecutor and ProcessPoolExecutor in Python

This article presents ten practical Python examples that demonstrate how to use ThreadPoolExecutor and ProcessPoolExecutor for concurrent tasks such as executing functions, downloading files, compressing data, performing calculations, handling large datasets, lazy file reading, prime filtering, and computing Fibonacci numbers.

ThreadPoolconcurrent.futuresprocesspool
0 likes · 6 min read
10 Practical Scenarios Using ThreadPoolExecutor and ProcessPoolExecutor in Python
JD Tech
JD Tech
Aug 1, 2023 · Fundamentals

JVM Initialization Deadlock Analysis and Resolution

This article investigates a production thread‑pool exhaustion issue caused by a JVM class‑initialization deadlock, explains the underlying class‑loading mechanics, presents detailed stack‑trace analysis, and offers a preventive solution with early bean initialization and a reproducible demo.

JVMThreadPoolclass loading
0 likes · 17 min read
JVM Initialization Deadlock Analysis and Resolution
Code Ape Tech Column
Code Ape Tech Column
Jul 17, 2023 · Backend Development

Best Practices and Common Pitfalls When Using Java Thread Pools

This article summarizes the key pitfalls and recommended practices for creating, configuring, monitoring, and naming Java thread pools, including proper declaration, parameter tuning for CPU‑ and I/O‑bound workloads, avoiding OOM and deadlocks, and leveraging dynamic pool frameworks.

BestPracticesJavaThreadPool
0 likes · 17 min read
Best Practices and Common Pitfalls When Using Java Thread Pools
Code Ape Tech Column
Code Ape Tech Column
Jul 10, 2023 · Operations

Fixing SkyWalking ThreadPool Plugin Enhancement Failure by Making AgentClassLoader a Singleton

This article details the investigation of a SkyWalking thread‑pool plugin enhancement failure caused by multiple AgentClassLoader instances, explains the debugging steps, class‑loading behavior, and provides two practical solutions to ensure proper bytecode instrumentation for ThreadPoolExecutor in Java applications.

APMAgentClassLoaderInstrumentation
0 likes · 16 min read
Fixing SkyWalking ThreadPool Plugin Enhancement Failure by Making AgentClassLoader a Singleton
FunTester
FunTester
Jun 28, 2023 · Backend Development

Designing a Go Coroutine Pool Based on Java ThreadPoolExecutor

This article explains how to implement a high‑performance Go coroutine pool by adapting key features of Java’s ThreadPoolExecutor, covering core parameters, task queue design, dynamic scaling, worker management, timeout handling, and provides complete code examples and self‑test results.

BackendGoThreadPool
0 likes · 10 min read
Designing a Go Coroutine Pool Based on Java ThreadPoolExecutor
Xiao Lou's Tech Notes
Xiao Lou's Tech Notes
Jun 26, 2023 · Backend Development

Why SkyWalking’s ThreadPool Plugin Failed and How I Fixed It

This article explains the root cause of the thread‑pool plugin enhancement failure in SkyWalking—duplicate AgentClassLoader instances—detailing the investigation steps, code changes, and two practical solutions to ensure reliable instrumentation of ThreadPoolExecutor.

DebuggingInstrumentationJavaAgent
0 likes · 18 min read
Why SkyWalking’s ThreadPool Plugin Failed and How I Fixed It
Cognitive Technology Team
Cognitive Technology Team
Jun 11, 2023 · Backend Development

Unified Handling of ThreadLocal Issues in Java Projects

This article explains why ThreadLocal can cause information loss, corruption, or OOM in Java applications and presents two practical approaches—Java agent bytecode manipulation and proxy‑based thread‑pool wrappers—along with concrete Spring Sleuth implementations and testing results to ensure safe propagation and cleanup.

JavaThreadLocalThreadPool
0 likes · 5 min read
Unified Handling of ThreadLocal Issues in Java Projects
FunTester
FunTester
Jun 6, 2023 · Backend Development

Dynamic Adjustment of Java ThreadPoolExecutor Core Pool Size Based on Queue Length

The article explains how to extend Java's ThreadPoolExecutor by dynamically increasing or decreasing corePoolSize according to the task queue length, using setCorePoolSize, a daemon monitoring thread, and scheduled tasks to improve asynchronous processing performance in Spring Boot applications.

CorePoolSizeDynamic ScalingSpringBoot
0 likes · 7 min read
Dynamic Adjustment of Java ThreadPoolExecutor Core Pool Size Based on Queue Length
DeWu Technology
DeWu Technology
Jun 2, 2023 · Backend Development

Implementing Dubbo Asynchronous Calls with CompletableFuture: Practices and Performance Gains

By refactoring Dubbo RPC interfaces to return CompletableFuture, applying thenApply/thenCombine/thenCompose patterns, isolating a custom business thread pool, and handling errors and tracing, the team achieved up to 50% latency reduction, 25% response‑time improvement, a one‑third server cut and CPU utilization rise, demonstrating substantial performance and cost benefits.

CompletableFutureDubboJava
0 likes · 19 min read
Implementing Dubbo Asynchronous Calls with CompletableFuture: Practices and Performance Gains
FunTester
FunTester
May 15, 2023 · Backend Development

Why Direct Thread Creation Fails and How Java Thread Pools Boost Performance

In high‑concurrency Java applications, creating threads directly with the Thread class leads to performance degradation, resource exhaustion, and lack of management, whereas using the Executor framework’s ThreadPoolExecutor—configured via corePoolSize, maximumPoolSize, keepAliveTime, workQueue, threadFactory, and rejectHandler—provides reusable threads, controlled concurrency, task scheduling, monitoring, and customizable rejection policies, dramatically improving efficiency.

ExecutorFrameworkJavaThreadPool
0 likes · 9 min read
Why Direct Thread Creation Fails and How Java Thread Pools Boost Performance
Selected Java Interview Questions
Selected Java Interview Questions
May 5, 2023 · Backend Development

High‑Frequency Java Concurrency Questions: AQS, Locks, Thread Pools, Blocking Queues, CountDownLatch, Semaphore, CopyOnWriteArrayList, and ConcurrentHashMap

This article explains the core concepts and common pitfalls of Java's AbstractQueuedSynchronizer (AQS) and its derived utilities such as ReentrantLock, ReentrantReadWriteLock, CountDownLatch, Semaphore, as well as the design and behavior of blocking queues, thread‑pool parameters, CopyOnWriteArrayList, and ConcurrentHashMap, providing code examples and practical guidance.

AQSBlockingQueueConcurrentHashMap
0 likes · 21 min read
High‑Frequency Java Concurrency Questions: AQS, Locks, Thread Pools, Blocking Queues, CountDownLatch, Semaphore, CopyOnWriteArrayList, and ConcurrentHashMap
Code Ape Tech Column
Code Ape Tech Column
Apr 25, 2023 · Backend Development

Advanced Java Multithreading: From Fundamentals to High‑Performance Transactional Scenarios

This article explores Java multithreading concepts, JVM safety tools, thread creation methods, coordination mechanisms, and practical scenarios such as parallel data aggregation, for‑loop conversion, map‑based processing, and multi‑threaded transaction handling, providing code examples and performance tips for backend developers.

CompletableFutureJavaThreadPool
0 likes · 22 min read
Advanced Java Multithreading: From Fundamentals to High‑Performance Transactional Scenarios
Zhuanzhuan Tech
Zhuanzhuan Tech
Apr 19, 2023 · Backend Development

Java Thread Pool Optimization and Dynamic Monitoring Practice at ZhiZhuan Platform

This article shares the author's experience with Java thread pools, covering initial concepts, parameter tuning, dynamic adjustment architecture, implementation details, and monitoring solutions applied in the ZhiZhuan platform to improve performance and reliability under high concurrency.

BackendOptimizationDynamicConfigurationJava
0 likes · 11 min read
Java Thread Pool Optimization and Dynamic Monitoring Practice at ZhiZhuan Platform
JD Cloud Developers
JD Cloud Developers
Apr 5, 2023 · Backend Development

Avoid Common ThreadPool Pitfalls in Java: Best Practices and Gotchas

This article examines frequent mistakes when using Java thread pools—such as improper creation, unreasonable parameters, unreleased local pools, and unsafe concurrent operations—and provides detailed analysis, configuration guidelines, and best‑practice recommendations to prevent memory leaks, deadlocks, and performance issues.

Garbage CollectionJavaThreadPool
0 likes · 17 min read
Avoid Common ThreadPool Pitfalls in Java: Best Practices and Gotchas
MaGe Linux Operations
MaGe Linux Operations
Apr 4, 2023 · Backend Development

Boost Python Scripts with map() Parallelism: From Threads to ThreadPools

Python’s traditional multithreading tutorials often overcomplicate simple tasks, but by leveraging the built‑in map() function and the multiprocessing.dummy ThreadPool, developers can dramatically simplify and accelerate I/O‑bound and CPU‑bound scripts, reducing code from dozens of lines to just a few while achieving significant speedups.

MAPParallelismThreadPool
0 likes · 13 min read
Boost Python Scripts with map() Parallelism: From Threads to ThreadPools
Selected Java Interview Questions
Selected Java Interview Questions
Mar 20, 2023 · Backend Development

Using Asynchronous Threads in Spring Boot: @Async, AsyncManager, and ThreadPoolExecutor

This article explains how to implement asynchronous processing in Java Spring Boot using the @Async annotation, the built‑in AsyncManager, and a custom ThreadPoolExecutor, providing code examples, configuration steps, and best‑practice tips for managing background tasks without blocking the main thread.

AsyncAsynchronousBackend Development
0 likes · 9 min read
Using Asynchronous Threads in Spring Boot: @Async, AsyncManager, and ThreadPoolExecutor
Selected Java Interview Questions
Selected Java Interview Questions
Mar 15, 2023 · Backend Development

Java ThreadPool Creation Methods and Usage Examples

This article explains the seven ways to create Java thread pools, categorizes them by ThreadPoolExecutor and Executors, and provides detailed code examples for fixed-size, cached, scheduled, single‑thread, work‑stealing pools, as well as custom thread factories and task result handling.

ExecutorServiceJavaScheduledExecutor
0 likes · 12 min read
Java ThreadPool Creation Methods and Usage Examples
Java Architect Essentials
Java Architect Essentials
Mar 14, 2023 · Backend Development

Using @Async in Spring: Built‑in Thread Pools, Their Limitations, and Custom Thread‑Pool Configuration

The article explains how Spring's @Async annotation works, compares synchronous and asynchronous calls, reviews the built‑in executors such as SimpleAsyncTaskExecutor, discusses their drawbacks, and provides detailed guidance on creating custom thread pools via AsyncConfigurer, AsyncConfigurerSupport, or a TaskExecutor bean, including code examples.

AsyncCustomExecutorThreadPool
0 likes · 9 min read
Using @Async in Spring: Built‑in Thread Pools, Their Limitations, and Custom Thread‑Pool Configuration
Code Ape Tech Column
Code Ape Tech Column
Mar 6, 2023 · Backend Development

Thread Creation Techniques in RocketMQ Source Code

This article explains how RocketMQ creates and manages threads, covering single‑thread creation via Runnable and Thread inheritance, the ServiceThread abstract class, ThreadPoolExecutor configuration, custom thread factories, and the importance of descriptive thread names for debugging.

BackendJavaMessaging
0 likes · 9 min read
Thread Creation Techniques in RocketMQ Source Code
Selected Java Interview Questions
Selected Java Interview Questions
Mar 3, 2023 · Backend Development

Comprehensive Guide to Java CompletableFuture: Asynchronous Tasks, Callbacks, and Multi‑Future Composition

This article explains Java's CompletableFuture API introduced in JDK 8, covering how to create asynchronous tasks with supplyAsync and runAsync, use various callback methods such as thenApply, thenAccept, thenRun, whenComplete, handle, and combine multiple futures with thenCombine, allOf, anyOf, providing code examples and execution results.

AsyncCompletableFutureFutureComposition
0 likes · 16 min read
Comprehensive Guide to Java CompletableFuture: Asynchronous Tasks, Callbacks, and Multi‑Future Composition
Java Architect Essentials
Java Architect Essentials
Feb 10, 2023 · Backend Development

Using MDC for TraceId Propagation in Java Backend Applications

This article explains what MDC (Mapped Diagnostic Context) is, outlines its API, demonstrates how to configure logging and interceptors, and provides concrete solutions—including a custom thread‑pool wrapper and HTTP client interceptors—to ensure TraceId is correctly propagated across threads and remote calls in Java backend systems.

InterceptorThreadPoollogging
0 likes · 12 min read
Using MDC for TraceId Propagation in Java Backend Applications
Code Ape Tech Column
Code Ape Tech Column
Feb 2, 2023 · Backend Development

Handling Exceptions in Java ThreadPool: submit vs execute and Custom Solutions

This article explains why tasks submitted to a Java ThreadPool via submit do not print exceptions, how to retrieve them using Future.get(), and presents three practical solutions—including try‑catch, Thread.setDefaultUncaughtExceptionHandler, and overriding afterExecute—to reliably capture and process thread pool exceptions.

ExecutorServiceJavaThreadPool
0 likes · 14 min read
Handling Exceptions in Java ThreadPool: submit vs execute and Custom Solutions
IT Architects Alliance
IT Architects Alliance
Feb 2, 2023 · Backend Development

Dynamic ThreadPool (DynamicTp) – Runtime Adjustable Thread Pool Framework Overview

The DynamicTp framework extends Java's ThreadPoolExecutor with runtime‑adjustable parameters, real‑time monitoring, alerting, and integration with multiple configuration centers, offering a lightweight, zero‑intrusion solution for microservice environments to improve performance and reliability.

Dynamic ConfigurationJavaMicroservices
0 likes · 9 min read
Dynamic ThreadPool (DynamicTp) – Runtime Adjustable Thread Pool Framework Overview
Su San Talks Tech
Su San Talks Tech
Jan 26, 2023 · Backend Development

How MemorySafeLBQ Prevents OOM in Java Thread Pools: A Deep Dive

This article examines the MemoryLimitedLBQ and MemorySafeLBQ implementations, explains how they use memory‑limiting techniques to avoid Out‑Of‑Memory errors in unbounded LinkedBlockingQueue‑based thread pools, compares their designs, and shows practical code snippets for integrating them into Java projects.

JavaMemoryManagementOOM
0 likes · 13 min read
How MemorySafeLBQ Prevents OOM in Java Thread Pools: A Deep Dive
Architecture Digest
Architecture Digest
Jan 15, 2023 · Backend Development

Debugging High CPU Usage in Nacos Config Client and Understanding Raft Network Partition

The article details a sudden CPU spike in a Java backend service using Nacos, walks through diagnosing the offending thread with top and jstack, analyzes Nacos client thread creation and scheduled gray‑config tasks, explains Raft network partition handling, and presents a fix that checks config health and avoids unnecessary thread creation.

CPUDebuggingJava
0 likes · 8 min read
Debugging High CPU Usage in Nacos Config Client and Understanding Raft Network Partition
Su San Talks Tech
Su San Talks Tech
Dec 9, 2022 · Backend Development

Master Asynchronous Java: Threads, Futures, CompletableFuture & Spring @Async

This article introduces asynchronous programming concepts in Java, explaining the shift from synchronous to asynchronous execution, and demonstrates practical implementations using raw threads, ThreadPoolExecutor, Future, FutureTask, CompletableFuture, and Spring's @Async annotation, along with event handling and message queue integration for high‑throughput systems.

AsynchronousCompletableFutureJava
0 likes · 16 min read
Master Asynchronous Java: Threads, Futures, CompletableFuture & Spring @Async
The Dominant Programmer
The Dominant Programmer
Nov 1, 2022 · Fundamentals

Master Java Multithreading and Custom Thread Pools in One Guide

This article explains why creating threads repeatedly wastes resources, introduces Java's ExecutorService thread pool, details its configuration parameters, demonstrates how to create and use fixed thread pools with Runnable and Callable tasks, shows proper shutdown, and highlights common pitfalls with Future.get.

CallableExecutorServiceFuture
0 likes · 9 min read
Master Java Multithreading and Custom Thread Pools in One Guide
FunTester
FunTester
Oct 19, 2022 · Backend Development

Controlling Java Async QPS with Semaphore and ThreadPool

This article explains how to use Java's java.util.concurrent.Semaphore together with a fixed-size thread pool to enforce a precise QPS limit for asynchronous tasks, providing API details, implementation steps, and a complete test example.

BackendJavaQPS
0 likes · 6 min read
Controlling Java Async QPS with Semaphore and ThreadPool
Cognitive Technology Team
Cognitive Technology Team
Oct 16, 2022 · Backend Development

Understanding ScheduledThreadPoolExecutor: Task Types, Configuration, and Common Pitfalls

This article explains the different delay and periodic task types supported by Java's ScheduledThreadPoolExecutor, details its constructor parameters and default settings, and highlights common pitfalls such as exception loss, inaccurate scheduling, and improper core pool size configuration.

Exception HandlingJavaScheduledThreadPoolExecutor
0 likes · 5 min read
Understanding ScheduledThreadPoolExecutor: Task Types, Configuration, and Common Pitfalls
Selected Java Interview Questions
Selected Java Interview Questions
Oct 11, 2022 · Backend Development

Handling Exceptions in Java Thread Pools: submit vs execute and Custom afterExecute

This article explains why tasks submitted to a Java thread pool via submit do not print exceptions, how to retrieve those exceptions using Future.get, and presents three practical solutions—including try‑catch, Thread.setDefaultUncaughtExceptionHandler, and overriding afterExecute—to reliably capture and process thread‑pool errors.

ExecutorServiceThreadPoolexceptionhandling
0 likes · 14 min read
Handling Exceptions in Java Thread Pools: submit vs execute and Custom afterExecute