BestHub
Sign in
Tagged articles

Java concurrency

100 articles · Page 1 of 1
Architecture Digest
Architecture Digest
Aug 18, 2026 · Backend Development

How to Design a ThreadPool to Send 10 Million SMS in One Hour – Interview Insights

Sending 10 million marketing SMS within an hour forces careful thread‑pool design: avoid unbounded queues that cause OOM, choose a bounded ThreadPoolExecutor, dynamically tune core/max sizes, use CallerRunsPolicy for natural back‑pressure, and add persistence and compensation mechanisms to guarantee reliability.

Java concurrencyOOM preventionThreadPoolExecutor
0 likes · 8 min read
How to Design a ThreadPool to Send 10 Million SMS in One Hour – Interview Insights
Coder Trainee
Coder Trainee
Jul 7, 2026 · Backend Development

Deep Dive into Java ThreadPoolExecutor: Source Code Analysis (Part 6)

This article provides a thorough, source‑level walkthrough of Java's ThreadPoolExecutor, covering its core design, state machine, seven key parameters, task‑submission flow, worker creation, execution loop, rejection policies, common pool variants, and interview‑ready explanations of the execute() process.

Java concurrencyRejectionPolicyThreadPool
0 likes · 10 min read
Deep Dive into Java ThreadPoolExecutor: Source Code Analysis (Part 6)
The Dominant Programmer
The Dominant Programmer
Jul 5, 2026 · Backend Development

Full Hands‑On Guide: Extending Spring AI Workflow Engine with Human‑in‑the‑Loop Approval

This article walks through adding a zero‑dependency human‑approval node to a Spring AI YAML‑DSL workflow engine, detailing the problem of critical business decisions, the JDK‑based pause‑and‑resume architecture, step‑by‑step code changes, best‑practice recommendations, and real‑world use cases such as large‑payment and content‑review approvals.

Java concurrencySpring AISpring Boot
0 likes · 24 min read
Full Hands‑On Guide: Extending Spring AI Workflow Engine with Human‑in‑the‑Loop Approval
samdeepthink
samdeepthink
Jun 24, 2026 · Backend Development

Choosing Between CompletableFuture and ForkJoinPool for High‑Concurrency Java Applications

The article explains that CompletableFuture always uses ForkJoinPool.commonPool by default, compares their suitability for CPU‑bound and I/O‑bound tasks, reveals risks of using the common pool under load, and provides concrete configuration patterns and benchmark results for safely isolating thread pools in production.

Bulkhead PatternCompletableFutureForkJoinPool
0 likes · 34 min read
Choosing Between CompletableFuture and ForkJoinPool for High‑Concurrency Java Applications
Programmer XiaoFu
Programmer XiaoFu
May 27, 2026 · Backend Development

Why Does a ThreadPool Queue Tasks Even When Max Threads Are Idle?

The article explains why Java's ThreadPoolExecutor places tasks into a queue before creating non‑core threads, discusses the cost of thread creation and CPU contention, illustrates the design with a bank‑counter analogy, and shows how Tomcat customizes the queue to prioritize thread creation for low‑latency web workloads.

Java concurrencyTaskQueueThread pool design
0 likes · 8 min read
Why Does a ThreadPool Queue Tasks Even When Max Threads Are Idle?
Programmer1970
Programmer1970
May 26, 2026 · Backend Development

7 Distributed Lock Implementations and Real‑World Pitfalls

The article explains why local locks fail in multi‑machine deployments, defines the three essential properties of a correct distributed lock, walks through seven Redis‑based lock solutions with code samples, highlights common production pitfalls, and provides a decision tree for selecting the right approach.

Fault ToleranceJava concurrencyRedis
0 likes · 10 min read
7 Distributed Lock Implementations and Real‑World Pitfalls
Code Ape Tech Column
Code Ape Tech Column
May 25, 2026 · Backend Development

Why Does TraceId Get Mixed Up Under High Concurrency Even Though the Parent Thread Passes It to Child Threads?

The article explains why InheritableThreadLocal fails to propagate TraceId correctly in high‑concurrency thread‑pool scenarios, demonstrates the mixing problem with concrete request examples, and presents both manual propagation and Alibaba's TransmittableThreadLocal as reliable solutions.

Context propagationInheritableThreadLocalJava concurrency
0 likes · 7 min read
Why Does TraceId Get Mixed Up Under High Concurrency Even Though the Parent Thread Passes It to Child Threads?
Programmer XiaoFu
Programmer XiaoFu
May 19, 2026 · Backend Development

Why Does TraceId Get Mixed Up Under High Concurrency Even Though the Parent Thread Passes It to Child Threads?

The article explains why InheritableThreadLocal fails to propagate TraceId correctly in thread‑pool scenarios under high load, illustrates the problem with concrete request examples, and presents manual propagation and Alibaba's TransmittableThreadLocal as solutions.

InheritableThreadLocalJava concurrencyThreadPoolExecutor
0 likes · 7 min read
Why Does TraceId Get Mixed Up Under High Concurrency Even Though the Parent Thread Passes It to Child Threads?
Lobster Programming
Lobster Programming
May 18, 2026 · Fundamentals

Why userId Gets Lost in Async Calls and How ThreadLocal Solves It

The article explains ThreadLocal's lifecycle, why userId disappears when spawning asynchronous threads, compares ThreadLocal, InheritableThreadLocal, and Alibaba's TransmittableThreadLocal, and shows how the latter prevents data contamination in thread‑pool reuse.

InheritableThreadLocalJava concurrencyThread Pool
0 likes · 5 min read
Why userId Gets Lost in Async Calls and How ThreadLocal Solves It
JavaGuide
JavaGuide
Feb 11, 2026 · Backend Development

Do ThreadLocal Values Fail in Asynchronous Scenarios? An Interviewer's Trick Question Explained

This article explains why ThreadLocal values are not automatically transferred in asynchronous or thread‑pool contexts, compares JDK's InheritableThreadLocal with Alibaba's TransmittableThreadLocal (TTL), and shows how TTL captures, replays, and restores context safely with code examples and diagrams.

Context propagationInheritableThreadLocalJava concurrency
0 likes · 13 min read
Do ThreadLocal Values Fail in Asynchronous Scenarios? An Interviewer's Trick Question Explained
Senior Xiao Ying
Senior Xiao Ying
Feb 6, 2026 · Fundamentals

StampedLock: The High‑Performance Java 8 Lock That Outpaces ReentrantReadWriteLock

StampedLock, introduced in Java 8, provides three lock modes—including an optimistic read that uses a 64‑bit stamp—to achieve higher throughput than ReentrantReadWriteLock in read‑heavy workloads, and the article explains its internal state, usage patterns, code examples, and important limitations.

Java 8Java concurrencyReentrantReadWriteLock
0 likes · 7 min read
StampedLock: The High‑Performance Java 8 Lock That Outpaces ReentrantReadWriteLock
Tech Freedom Circle
Tech Freedom Circle
Jan 27, 2026 · Interview Experience

Netease Interview: Write a BlockingQueue in 5 Minutes and Explain Design Patterns & Principles

The article breaks down a common Netease interview task—hand‑coding a BlockingQueue in five minutes—by explaining the underlying lock‑and‑condition mechanism, the relevant design patterns and principles, common pitfalls such as spurious wakeups, and provides a concise, 50‑line Java implementation with step‑by‑step commentary.

Design PatternsInterview PreparationJava concurrency
0 likes · 20 min read
Netease Interview: Write a BlockingQueue in 5 Minutes and Explain Design Patterns & Principles
Tech Freedom Circle
Tech Freedom Circle
Dec 17, 2025 · Backend Development

Thread Pool: Shared vs Exclusive – How to Choose the Right Strategy for Critical Java Services

This article dissects the interview question “Should thread pools be shared or exclusive?” by exposing common pitfalls, presenting a systematic analysis of isolation versus reuse, and illustrating best‑practice designs with concrete RocketMQ examples, code snippets, and decision‑making guidelines.

IsolationJava concurrencyRocketMQ
0 likes · 22 min read
Thread Pool: Shared vs Exclusive – How to Choose the Right Strategy for Critical Java Services
vivo Internet Technology
vivo Internet Technology
Dec 3, 2025 · Mobile Development

How Parallel Loading Supercharges H5 Instant SDK: Challenges, Early Designs, and Optimized Solutions

This article explains the parallel loading technique used in the H5 instant SDK to accelerate page startup, details the three resource‑handoff scenarios that cause synchronization challenges, reviews the early simple design and its drawbacks, and presents an optimized producer‑consumer model with fair locks and bridge streams to eliminate wasteful waiting and memory consumption.

H5 instant SDKJava concurrencyParallel Loading
0 likes · 31 min read
How Parallel Loading Supercharges H5 Instant SDK: Challenges, Early Designs, and Optimized Solutions
Ubiquitous Tech
Ubiquitous Tech
Nov 24, 2025 · Backend Development

DynamicTp Startup and Configuration Change Flow: A Deep Dive into Dynamic Thread Pool Design

This article walks through the internal startup sequence and runtime configuration‑change mechanism of the open‑source DynamicTp dynamic thread‑pool, covering Spring Boot starter integration, @EnableDynamicTp annotation processing, Nacos‑driven property refresh, SPI extensibility, queue adaptation, and graceful shutdown, all illustrated with concrete code snippets and diagrams.

Configuration RefreshDynamicTpJava concurrency
0 likes · 16 min read
DynamicTp Startup and Configuration Change Flow: A Deep Dive into Dynamic Thread Pool Design
Top Architect
Top Architect
Nov 10, 2025 · Backend Development

Mastering Request Merging: Hystrix Collapser, BatchCollapser & ConcurrentHashMultiset Explained

This article explores how merging similar requests upstream can dramatically reduce downstream load, detailing Hystrix Collapser usage and configuration, a custom BatchCollapser implementation with time‑ and count‑based triggers, and the thread‑safe ConcurrentHashMultiset for high‑duplicate statistical scenarios.

BatchCollapserConcurrentHashMultisetHystrix
0 likes · 13 min read
Mastering Request Merging: Hystrix Collapser, BatchCollapser & ConcurrentHashMultiset Explained
Architect's Guide
Architect's Guide
Oct 3, 2025 · Backend Development

Merge Duplicate Requests Using Hystrix Collapser, BatchCollapser, and ConcurrentHashMultiset

This article explains how merging similar or duplicate requests upstream with Hystrix Collapser, a custom BatchCollapser, and Guava's ConcurrentHashMultiset can dramatically reduce downstream load, improve system throughput, and outlines their implementations, configurations, and ideal use‑cases.

Batch ProcessingHystrixJava concurrency
0 likes · 15 min read
Merge Duplicate Requests Using Hystrix Collapser, BatchCollapser, and ConcurrentHashMultiset
IT Services Circle
IT Services Circle
Sep 17, 2025 · Backend Development

Ace ByteDance Java Interview: Concurrency, Thread Pools, Redis & MySQL Deep Dive

This article walks through essential ByteDance Java interview topics, covering thread safety fundamentals, thread‑pool configuration, Redis performance tricks, Zset and skip‑list internals, memory‑policy handling, cache‑consistency patterns, and MySQL transaction ACID properties, providing code examples and best‑practice recommendations.

Cache ConsistencyJava concurrencyMySQL transaction
0 likes · 25 min read
Ace ByteDance Java Interview: Concurrency, Thread Pools, Redis & MySQL Deep Dive
JD Tech Talk
JD Tech Talk
Jul 1, 2025 · Fundamentals

How False Sharing Slows Down Multithreaded Java Apps—and How to Fix It

This article explains the hidden performance killer of cache false sharing in multicore Java applications, demonstrates its impact with benchmark code, and shows how padding, the @Contended annotation, and Caffeine's internal structures can eliminate the issue for faster execution.

Cache OptimizationCaffeineContended
0 likes · 10 min read
How False Sharing Slows Down Multithreaded Java Apps—and How to Fix It
Su San Talks Tech
Su San Talks Tech
May 19, 2025 · Backend Development

Mastering Asynchronous Architecture: Real‑World Scenarios and Spring Cloud Gateway

This article explains synchronous versus asynchronous processing through a parcel‑delivery example, outlines core async concepts, presents common async techniques such as message queues, event‑driven design and non‑blocking I/O, and demonstrates practical implementations with Spring Cloud Gateway, Netty, ELK‑Kafka pipelines, and CompletableFuture batch processing.

Asynchronous ProgrammingJava concurrencyMessage Queue
0 likes · 17 min read
Mastering Asynchronous Architecture: Real‑World Scenarios and Spring Cloud Gateway
macrozheng
macrozheng
May 16, 2025 · Fundamentals

Why More Threads Can Slow Down Your Java App—and How to Optimize Context Switching

This article explains how CPU time slices, hyper‑threading, and context‑switching affect multithreaded performance, outlines the costs of thread switches, and offers practical strategies such as lock‑free programming, CAS, reducing thread count, and using coroutines to improve efficiency.

CPU schedulingHyper-ThreadingJava concurrency
0 likes · 11 min read
Why More Threads Can Slow Down Your Java App—and How to Optimize Context Switching
Java Backend Technology
Java Backend Technology
Mar 8, 2025 · Backend Development

How to Merge Concurrent Requests in Spring Boot and Save Database Connections

This article explains how to batch multiple user‑info requests on the server side, merge them into a single SQL query using a blocking queue and ScheduledThreadPoolExecutor, and return the results individually, thereby reducing database connection usage and improving performance under high concurrency.

Batch ProcessingCompletableFutureJava concurrency
0 likes · 13 min read
How to Merge Concurrent Requests in Spring Boot and Save Database Connections
Programmer Xu Shu
Programmer Xu Shu
Feb 24, 2025 · Backend Development

Mastering Thread Pool Tuning: Real‑World Strategies from a Meituan Interview

This article breaks down essential thread‑pool parameters, explains how to set corePoolSize and maximumPoolSize for CPU‑ and IO‑bound tasks, and outlines a practical, dynamic adjustment process—including monitoring, strategy definition, load testing, and automation—to achieve optimal performance in production environments.

Dynamic ScalingJava concurrencyThread Pool
0 likes · 8 min read
Mastering Thread Pool Tuning: Real‑World Strategies from a Meituan Interview
Sohu Tech Products
Sohu Tech Products
Feb 19, 2025 · Fundamentals

Deep Dive into ReentrantLock: Fair Lock vs Non-Fair Lock Implementation Principles

The article explains Java’s ReentrantLock implementation, contrasting fair locks that queue threads in request order with non‑fair locks that allow immediate acquisition, detailing the internal Sync, FairSync and NonfairSync classes, lock/unlock mechanisms, performance trade‑offs, and guidance on selecting the appropriate lock type.

AQSJUCJava concurrency
0 likes · 19 min read
Deep Dive into ReentrantLock: Fair Lock vs Non-Fair Lock Implementation Principles
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Jan 21, 2025 · Fundamentals

Understanding CAS: Solving the ABA Problem and Other Pitfalls in Java Concurrency

This article explains the classic ABA issue in Java's Compare‑And‑Swap (CAS) operations, outlines why long spin loops and single‑variable limitations can degrade performance, and presents practical solutions such as AtomicStampedReference, LockSupport, ReentrantLock, and optimized data structures to mitigate these challenges.

ABA problemCASJava concurrency
0 likes · 4 min read
Understanding CAS: Solving the ABA Problem and Other Pitfalls in Java Concurrency
IT Services Circle
IT Services Circle
Jan 9, 2025 · Backend Development

LMAX Disruptor: High‑Performance In‑Memory Queue and Its Typical Use Cases

The article introduces LMAX Disruptor, a high‑performance, lock‑free in‑memory queue for the JVM, compares it with JDK thread‑safe queues, and demonstrates five practical usage scenarios—including broadcast, log collection, chain of responsibility, multi‑task coordination, and multi‑consumer groups—through detailed Java code examples.

DisruptorEvent ProcessingHigh performance queue
0 likes · 10 min read
LMAX Disruptor: High‑Performance In‑Memory Queue and Its Typical Use Cases
Code Ape Tech Column
Code Ape Tech Column
Dec 24, 2024 · Backend Development

Understanding the Disruptor In-Memory Message Queue: Architecture, Features, and Tuning

This article introduces the Disruptor in‑memory message queue, explains its core components such as Ring Buffer, Sequence, Sequencer and Wait Strategies, describes its distinctive features like multicast events and lock‑free concurrency, and provides tuning guidelines and a complete Java example.

DisruptorIn-Memory QueueJava concurrency
0 likes · 11 min read
Understanding the Disruptor In-Memory Message Queue: Architecture, Features, and Tuning
Shepherd Advanced Notes
Shepherd Advanced Notes
Dec 17, 2024 · Backend Development

Spring Boot Scheduling: Timer vs ScheduledExecutorService vs @Scheduled

This article compares three single‑node scheduling approaches in Spring Boot—Java's legacy Timer, the modern ScheduledExecutorService, and Spring's @Scheduled annotation—showing their implementations, execution characteristics, thread handling, error behavior, and when to prefer each solution.

@ScheduledJava concurrencyScheduledExecutorService
0 likes · 19 min read
Spring Boot Scheduling: Timer vs ScheduledExecutorService vs @Scheduled
FunTester
FunTester
Dec 4, 2024 · Backend Development

Mastering Custom ThreadPoolExecutor: Build Flexible Java Thread Pools

This article explains why the standard Executors factory methods may be insufficient, details each ThreadPoolExecutor constructor parameter, demonstrates how to configure a custom pool for performance testing, and walks through multiple code examples that illustrate thread creation, queue behavior, and rejection policies.

Java concurrencyPerformance TestingThreadPool
0 likes · 14 min read
Mastering Custom ThreadPoolExecutor: Build Flexible Java Thread Pools
Sohu Tech Products
Sohu Tech Products
Jul 17, 2024 · Backend Development

Java Thread Pool: Working Mechanism, States, and Rejection Policies

Java thread pools efficiently manage and reuse threads by applying a producer‑consumer model, transitioning through RUNNING, SHUTDOWN, STOP, and TERMINATED states, handling task queues, and employing configurable rejection policies such as Abort, CallerRuns, Discard, and DiscardOldest, while improving performance, resource utilization, and stability across web servers, asynchronous processing, and other concurrent workloads, distinct from connection pools which manage database connections.

Java concurrencyThread PoolThreadPoolExecutor
0 likes · 12 min read
Java Thread Pool: Working Mechanism, States, and Rejection Policies
Selected Java Interview Questions
Selected Java Interview Questions
Nov 22, 2023 · Backend Development

Thread Pool Pitfalls and Best Practices in Java Backend Development

This article analyzes a real production incident caused by improper thread‑pool usage, explains common misconceptions about core parameters, demonstrates faulty code examples, and provides concrete recommendations for configuring thread pools, handling timeouts, and avoiding deadlocks in Java backend services.

CompletableFutureDeadlockJava concurrency
0 likes · 14 min read
Thread Pool Pitfalls and Best Practices in Java Backend Development
macrozheng
macrozheng
Oct 27, 2023 · Backend Development

Unlock 20× Faster Java Concurrency with JDK21 Virtual Threads

This article explains JDK21's new virtual threads, compares them with traditional thread pools through a 10,000‑thread benchmark, shows over 20‑fold performance gains, and provides practical code examples and configuration tips for Java developers.

JDK21Java concurrencyPerformance Test
0 likes · 8 min read
Unlock 20× Faster Java Concurrency with JDK21 Virtual Threads
JD Cloud Developers
JD Cloud Developers
Oct 11, 2023 · Backend Development

How Many Threads Should You Run? Real‑World Tests Reveal the Truth

This article debunks common thread‑count myths by running Java CPU‑bound and I/O‑bound experiments on a 6‑core/12‑thread Ryzen, showing how core count, context‑switching overhead, and I/O wait time affect CPU utilization and guiding practical thread‑pool sizing.

Java concurrencyPerformance Testingcpu-utilization
0 likes · 12 min read
How Many Threads Should You Run? Real‑World Tests Reveal the Truth
Top Architect
Top Architect
Oct 8, 2023 · Backend Development

Merging Backend Requests in SpringBoot to Reduce Database Connections

This article explains how to merge multiple backend requests in a SpringBoot application using a blocking queue, ScheduledThreadPoolExecutor, and CompletableFuture to batch database queries, reduce connection overhead, handle high concurrency, and includes full Java code examples and performance testing.

Batch ProcessingJava concurrencySpringBoot
0 likes · 15 min read
Merging Backend Requests in SpringBoot to Reduce Database Connections
Architect
Architect
Oct 1, 2023 · Backend Development

Batch Request Merging in Spring Boot to Reduce Database Connections

This article demonstrates how to merge multiple user‑info requests on the server side using a blocking queue, ScheduledThreadPoolExecutor, and CompletableFuture in Spring Boot, thereby consolidating SQL queries into a single batch call to save database connection resources while handling high concurrency.

Batch ProcessingCompletableFutureJava concurrency
0 likes · 13 min read
Batch Request Merging in Spring Boot to Reduce Database Connections
Java Architecture Diary
Java Architecture Diary
Jun 21, 2023 · Backend Development

Boost Java Concurrency with Project Loom: A Hands‑On Guide to Virtual Threads

Learn how Project Loom’s virtual threads can replace heavyweight OS threads in Java Spring Boot applications, enabling one‑thread‑per‑request models, improving throughput under high concurrency, with step‑by‑step setup, code samples, and performance comparisons across 100‑, 300‑ and 500‑thread tests.

Java concurrencyPerformance TestingProject Loom
0 likes · 7 min read
Boost Java Concurrency with Project Loom: A Hands‑On Guide to Virtual Threads
HomeTech
HomeTech
Jun 14, 2023 · Backend Development

Design and Implementation of a Task Orchestration Framework for Business Systems

This article introduces the background, core concepts, architecture, and implementation details of a lightweight Java task orchestration framework that simplifies complex business workflows by managing task dependencies, parallel execution, and error handling, thereby improving development efficiency and system maintainability.

Java concurrencyTask orchestrationWorkflow Engine
0 likes · 25 min read
Design and Implementation of a Task Orchestration Framework for Business Systems
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.

Java concurrencyThread PoolThreadPoolExecutor
0 likes · 17 min read
Understanding ThreadPoolExecutor: Key Parameters and Source Code Analysis
ITPUB
ITPUB
Sep 14, 2022 · Backend Development

Mastering Thread Creation in RocketMQ: From ServiceThread to ThreadPoolExecutor

This article explains how RocketMQ creates and manages threads, covering single‑thread techniques, the ServiceThread abstract class, ThreadPoolExecutor fundamentals, custom thread‑pool wrappers, and the critical role of descriptive thread names for debugging and performance monitoring.

Java concurrencyRocketMQServiceThread
0 likes · 8 min read
Mastering Thread Creation in RocketMQ: From ServiceThread to ThreadPoolExecutor
Senior Brother's Insights
Senior Brother's Insights
May 24, 2022 · Fundamentals

Why Does Thread A Always Grab the Lock First? A Deep Dive into Java Synchronization, JVM Internals, and CPU Fundamentals

This article explores the evolution from early mechanical calculators to modern CPUs, explains thread states, synchronization mechanisms, memory barriers, volatile semantics, and JVM lock implementations, and reveals why Java's notify method consistently awakens a specific waiting thread.

CASCPU architectureComputer History
0 likes · 39 min read
Why Does Thread A Always Grab the Lock First? A Deep Dive into Java Synchronization, JVM Internals, and CPU Fundamentals
Java Backend Technology
Java Backend Technology
May 23, 2022 · Backend Development

Is Your Spring MVC Controller Thread‑Safe? Understand and Fix It

This article explains what thread safety means, demonstrates how a simple counter can become unsafe under concurrent requests, shows Java code examples of the problem and its synchronized solution, and provides practical guidelines for ensuring Spring MVC controllers remain thread‑safe by avoiding shared mutable state or using synchronization mechanisms such as synchronized blocks or ThreadLocal.

ControllerJava concurrencyThread Safety
0 likes · 5 min read
Is Your Spring MVC Controller Thread‑Safe? Understand and Fix It
IT Architects Alliance
IT Architects Alliance
May 14, 2022 · Backend Development

Request Collapsing Techniques: Hystrix Collapser, Custom BatchCollapser, and ConcurrentHashMultiset

This article compares three request‑collapsing techniques—Hystrix Collapser, a custom BatchCollapser, and Guava’s ConcurrentHashMultiset—detailing their designs, implementations, configurations, and suitable scenarios for reducing downstream load and improving system throughput, including code examples, timer‑based batching, and thread‑safe container usage.

Batch ProcessingGuavaHystrix
0 likes · 14 min read
Request Collapsing Techniques: Hystrix Collapser, Custom BatchCollapser, and ConcurrentHashMultiset
58 Tech
58 Tech
May 10, 2022 · Backend Development

Understanding Distributed Locks: Java Native Locks, RedissonLock, RedLock, and WLock – Concepts, Algorithms, and Source Code Analysis

This article explains the need for distributed locks, compares Java native and JUC locks, details Redis‑based implementations such as RedissonLock and RedLock, introduces the WLock solution with WPaxos and RocksDB, and provides complete source‑code walkthroughs for lock acquisition and release.

Java concurrencyRedissonWLock
0 likes · 31 min read
Understanding Distributed Locks: Java Native Locks, RedissonLock, RedLock, and WLock – Concepts, Algorithms, and Source Code Analysis
Top Architect
Top Architect
Dec 17, 2021 · Operations

API Load Testing with Postman, ApacheBench, JMeter, and Java Concurrency

This article demonstrates how to use Postman for basic HTTP requests, ApacheBench and JMeter for load testing, and Java's CountDownLatch and Semaphore classes to simulate concurrent requests, providing step‑by‑step instructions, code examples, and configuration details for effective API performance testing.

JMeterJava concurrencyLoad Testing
0 likes · 10 min read
API Load Testing with Postman, ApacheBench, JMeter, and Java Concurrency
Programmer DD
Programmer DD
Dec 17, 2021 · Backend Development

Mastering API Load Testing: Postman, ApacheBench, JMeter & Java Concurrency

This guide walks you through using Postman for basic API calls and concurrency testing, setting up ApacheBench on Windows, configuring and running JMeter for performance testing, and implementing custom load simulations in Java with CountDownLatch and Semaphore to understand thread coordination and bottlenecks.

API testingJMeterJava concurrency
0 likes · 8 min read
Mastering API Load Testing: Postman, ApacheBench, JMeter & Java Concurrency
Open Source Linux
Open Source Linux
Dec 16, 2021 · Fundamentals

From Mechanical Calculators to Modern CPUs: Exploring Computer Fundamentals and Java Concurrency

This comprehensive guide traces the evolution of computing from early mechanical calculators to today's CPUs, delving into binary systems, memory hierarchies, synchronization primitives, thread states, lock mechanisms, and Java concurrency intricacies, while providing code examples, diagrams, and interview insights for developers.

CPU architectureJava concurrencyLocks
0 likes · 38 min read
From Mechanical Calculators to Modern CPUs: Exploring Computer Fundamentals and Java Concurrency
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.

Java concurrencyShutdownThread Pool
0 likes · 33 min read
In‑Depth Analysis of JDK ThreadPoolExecutor: Construction, Execution Flow, Worker Mechanics, Shutdown and Custom Extensions
Senior Brother's Insights
Senior Brother's Insights
Nov 1, 2021 · Backend Development

Mastering Java ThreadPoolExecutor: Design, Configuration, and Best Practices

This article explains why using ThreadPoolExecutor directly is preferred over Executors, details the thread pool's purpose, internal architecture, task handling flow, state management, API parameters, queue choices, rejection policies, sizing formulas, and provides practical code examples for custom thread pool implementations.

CustomThreadFactoryJava concurrencyRejectionPolicy
0 likes · 22 min read
Mastering Java ThreadPoolExecutor: Design, Configuration, and Best Practices
FunTester
FunTester
Oct 13, 2021 · Operations

Dynamic Load Adjustment in FunTester: A Real‑World Pressure‑Control Demo

This article details the design and implementation of a dynamic pressure model for the FunTester performance testing framework, covering the goal of flexible load adjustments, core features, multithread synchronization using Phaser, code examples, a demo execution, console output analysis, and identified limitations.

FunTesterJava concurrencyLoad Testing
0 likes · 15 min read
Dynamic Load Adjustment in FunTester: A Real‑World Pressure‑Control Demo
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Sep 1, 2021 · Backend Development

Boost Spring Boot Order Calls: Sync vs Async with ThreadPool & CompletableFuture

This article compares synchronous and various asynchronous approaches for invoking multiple third‑party services in a Spring Boot order‑creation workflow, demonstrating plain sequential calls, manual thread creation, thread‑pool execution, CompletionService handling, and CompletableFuture composition, and shows their performance impact through timing results.

Asynchronous ProgrammingCompletableFutureJava concurrency
0 likes · 8 min read
Boost Spring Boot Order Calls: Sync vs Async with ThreadPool & CompletableFuture
New Oriental Technology
New Oriental Technology
May 31, 2021 · Backend Development

A Comprehensive Guide to Java Concurrency and Synchronization Mechanisms

This article provides an in-depth exploration of Java concurrency and synchronization mechanisms, detailing the evolution of the Java Memory Model, explaining core concepts like volatile, CAS, synchronized, and park/unpark, and illustrating their practical applications through code examples and JVM optimization insights.

CASJVM OptimizationJava concurrency
0 likes · 15 min read
A Comprehensive Guide to Java Concurrency and Synchronization Mechanisms
Alibaba Cloud Developer
Alibaba Cloud Developer
May 31, 2021 · Backend Development

Why corePoolSize=0 Behaves Differently in Java ThreadPoolExecutor and How to Optimize It

This article explains the nuances of ThreadPoolExecutor configuration in Java, covering the behavior of corePoolSize=0, core thread creation, termination policies, keepAliveTime effects, exception handling, shutdown strategies, Spring alternatives, and practical best‑practice recommendations for robust backend concurrency management.

Java concurrencyThreadPoolThreadPoolExecutor
0 likes · 21 min read
Why corePoolSize=0 Behaves Differently in Java ThreadPoolExecutor and How to Optimize It
vivo Internet Technology
vivo Internet Technology
Jan 27, 2021 · Backend Development

TransmittableThreadLocal Practice: Solving Multi-Country Business Context Propagation in E-commerce

The article explains how to reliably propagate country‑specific context across request handling, database access, and asynchronous thread pools in multi‑country e‑commerce by replacing simple ThreadLocal and InheritableThreadLocal with Alibaba’s TransmittableThreadLocal, demonstrating its integration with Spring MVC/Boot, MyBatis, Dubbo, and custom executors for both sharded and non‑sharded databases.

AlibabaInheritableThreadLocalJava concurrency
0 likes · 16 min read
TransmittableThreadLocal Practice: Solving Multi-Country Business Context Propagation in E-commerce
Code Ape Tech Column
Code Ape Tech Column
Dec 27, 2020 · Backend Development

Why ThreadLocal and ConcurrentHashMap Can Still Cause Bugs—and How to Fix Them

This article examines common misconceptions about Java concurrency utilities such as ThreadLocal, ConcurrentHashMap, and CopyOnWriteArrayList, demonstrates real‑world bugs caused by thread reuse and non‑atomic operations, and provides concrete solutions and performance‑tested alternatives.

ConcurrentHashMapCopyOnWriteArrayListJava concurrency
0 likes · 12 min read
Why ThreadLocal and ConcurrentHashMap Can Still Cause Bugs—and How to Fix Them
Selected Java Interview Questions
Selected Java Interview Questions
Dec 26, 2020 · Backend Development

Thread Reuse Pitfalls, ThreadLocal Misuse, and Proper Use of ConcurrentHashMap and CopyOnWriteArrayList

This article explains how thread reuse in a Tomcat thread pool can cause user‑information leakage when ThreadLocal is misused, analyzes the non‑atomic behavior of ConcurrentHashMap operations, demonstrates performance differences between locking and atomic methods, and warns against inappropriate use of CopyOnWriteArrayList in high‑write scenarios.

ConcurrentHashMapCopyOnWriteArrayListJava concurrency
0 likes · 13 min read
Thread Reuse Pitfalls, ThreadLocal Misuse, and Proper Use of ConcurrentHashMap and CopyOnWriteArrayList
Java Backend Technology
Java Backend Technology
Nov 12, 2020 · Backend Development

Why Java Locks Fail in Distributed Systems and How Redis & Zookeeper Fix Them

Java’s built‑in synchronization mechanisms work only within a single JVM, leading to inventory‑oversell problems when scaling an e‑commerce service across multiple machines, so developers turn to distributed lock solutions such as Redis (with RedLock or Redisson) and Zookeeper (using ordered and temporary nodes) to ensure global mutual exclusion.

CuratorJava concurrencyRedisson
0 likes · 19 min read
Why Java Locks Fail in Distributed Systems and How Redis & Zookeeper Fix Them
Programmer DD
Programmer DD
Oct 29, 2020 · Backend Development

Why Reactive Programming Is the Future of High‑Concurrency Java Development

This article explains how reactive programming, introduced by Microsoft in 2009 and adopted by Java through Spring Reactor and RxJava, addresses high‑concurrency server‑side challenges by using event‑driven, back‑pressure‑aware streams, and compares the key differences between Reactor and RxJava.

Java concurrencyRxJavaSpring Reactor
0 likes · 12 min read
Why Reactive Programming Is the Future of High‑Concurrency Java Development
JavaEdge
JavaEdge
Oct 8, 2020 · Backend Development

How Disruptor Achieves Lock-Free Speed: Single-Threaded Writes, Memory Barriers, and False Sharing

This article explains how the Disruptor library attains true lock‑free performance through single‑threaded writes, the use of memory barriers (volatile and happens‑before semantics), cache‑line alignment to eliminate false sharing, and a sequence‑barrier algorithm, providing code examples and practical optimization tips.

DisruptorJava concurrencyLock-Free
0 likes · 5 min read
How Disruptor Achieves Lock-Free Speed: Single-Threaded Writes, Memory Barriers, and False Sharing
Youzan Coder
Youzan Coder
Jul 8, 2020 · Backend Development

Druid Connection Pool Performance Optimization: Fair Lock vs Unfair Lock

The article explains how a Druid 1.1.20 connection pool was throttled to ~10k RPS by fair‑locking in recycle(), and how enabling the unfair lock (setUseUnfairLock(true)) doubled single‑machine TPS, raised CPU usage to near 100 % and boosted cluster throughput by about 70 %.

ArthasDatabaseDruid
0 likes · 7 min read
Druid Connection Pool Performance Optimization: Fair Lock vs Unfair Lock
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
Xiao Lou's Tech Notes
Xiao Lou's Tech Notes
Jun 18, 2020 · Backend Development

How to Build an Ultra‑Fast Ring Buffer for Producer‑Consumer in Java

This article explains a high‑performance ring buffer implementation for a multi‑threaded producer‑consumer model in Java, covering design choices, atomic index handling, benchmark results, and further optimizations such as cache‑line padding and multi‑buffer sharding.

AtomicIntegerJava concurrencyRing Buffer
0 likes · 10 min read
How to Build an Ultra‑Fast Ring Buffer for Producer‑Consumer in Java
Architecture Digest
Architecture Digest
Jun 16, 2020 · Backend Development

Why Use Distributed Locks? Implementation with Redis, Redisson, and Zookeeper

The article explains the inventory oversell problem in distributed e‑commerce systems, why native JVM locks fail across multiple machines, and presents practical implementations of distributed locks using Redis (including RedLock and Redisson) and Zookeeper (with Curator), comparing their advantages and drawbacks.

Java concurrencydistributed lockdistributed systems
0 likes · 17 min read
Why Use Distributed Locks? Implementation with Redis, Redisson, and Zookeeper
Xiao Lou's Tech Notes
Xiao Lou's Tech Notes
May 19, 2020 · Backend Development

Can You Build a Faster Counter Than Java’s LongAdder? A Deep Dive

An in‑depth Java performance study explores LongAdder, compares it with AtomicLong and lock‑based counters using JMH, and walks through successive custom implementations (V0‑V5) that apply striping, modulo optimization, false‑sharing elimination, and advanced hash probing to approach or surpass LongAdder’s throughput.

JMHJava concurrencyfalse sharing
0 likes · 16 min read
Can You Build a Faster Counter Than Java’s LongAdder? A Deep Dive
FunTester
FunTester
Feb 14, 2020 · Backend Development

How Pre‑Signing Parameters and a Thread‑Safe Queue Slash API Test Latency

The article explains why API‑testing threads sometimes pause for milliseconds during parameter signing, proposes pre‑signing all data and using a LinkedBlockingDeque to store signed maps, and provides a complete Java implementation that dramatically reduces per‑request overhead.

API testingJava concurrencyLinkedBlockingDeque
0 likes · 8 min read
How Pre‑Signing Parameters and a Thread‑Safe Queue Slash API Test Latency
JD Retail Technology
JD Retail Technology
Jan 21, 2020 · Backend Development

From Zero to Launch: Building JD.com’s UGC “Home Page Takeover” Project in 60 Days

This article details how JD.com’s engineering team designed, implemented, and optimized a user‑generated‑content platform that went from concept to production in 60 days, covering project background, system architecture, data storage with JimDB, messaging decoupling, asynchronous I/O, performance testing, and future improvements.

Java concurrencyRedisUGC
0 likes · 11 min read
From Zero to Launch: Building JD.com’s UGC “Home Page Takeover” Project in 60 Days
JavaEdge
JavaEdge
Jan 9, 2020 · Fundamentals

Why False Sharing Slows Your Java Programs and How to Eliminate It

False sharing occurs when multiple threads modify variables that reside on the same CPU cache line, causing unnecessary cache coherency traffic; this article explains cache line basics, CPU cache hierarchy, MESI protocol, and presents Java solutions—including padding, @sun.misc.Contended annotation, and JVM flags—to prevent performance degradation.

Java concurrencycache linefalse sharing
0 likes · 9 min read
Why False Sharing Slows Your Java Programs and How to Eliminate It
dbaplus Community
dbaplus Community
Jun 16, 2019 · Fundamentals

Understanding Thread Safety: From ThreadLocal to Locks and CAS

This article explains why thread safety concerns memory rather than threads, compares stack‑local and heap‑shared data, introduces ThreadLocal for per‑thread isolation, and covers mutual‑exclusion locks, optimistic CAS, and their appropriate use cases in concurrent programming.

CASJava concurrencyLocks
0 likes · 15 min read
Understanding Thread Safety: From ThreadLocal to Locks and CAS
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Mar 9, 2019 · Backend Development

Boost High-Concurrency Performance with Request Merging in Java

By introducing request merging and batch APIs, this article demonstrates how to improve high‑concurrency performance in Java backend services, detailing the design, data structures, scheduled execution, and code implementation while discussing trade‑offs and practical considerations.

Java concurrencybatch APIhigh concurrency
0 likes · 8 min read
Boost High-Concurrency Performance with Request Merging in Java
Programmer DD
Programmer DD
Oct 9, 2018 · Backend Development

Master Java Parallelism: From CountDownLatch to Fork/Join and Beyond

This article explores the evolution of parallel computing in Java, explaining why single‑core performance stalls, how multi‑core CPUs and GPUs enable true concurrency, and demonstrating practical implementations using CountDownLatch, CompletableFuture, Fork/Join, parallel streams, and sharding, while highlighting performance considerations and pitfalls.

CompletableFutureCountDownLatchForkJoinPool
0 likes · 15 min read
Master Java Parallelism: From CountDownLatch to Fork/Join and Beyond
Java Captain
Java Captain
Sep 25, 2018 · Fundamentals

Optimistic vs Pessimistic Locks and CAS Implementation in Java

The article explains the concepts of pessimistic and optimistic locking, details how CAS (Compare‑And‑Swap) implements optimistic locks in Java, discusses their advantages, drawbacks such as the ABA problem and high spin costs, and compares CAS usage with synchronized blocks in concurrent programming.

CASJava concurrencyatomic
0 likes · 14 min read
Optimistic vs Pessimistic Locks and CAS Implementation in Java
Programmer DD
Programmer DD
Sep 25, 2018 · Fundamentals

Why Disruptor Beats Traditional Queues: Inside Java’s High‑Performance RingBuffer

This article explains how the Disruptor library implements lock‑free, bounded queues using a ring‑buffer, cache‑line padding and CAS operations, compares single‑ and multi‑producer sequencers, and provides practical Java code examples for building ultra‑low‑latency producer‑consumer pipelines.

High performance queueJava concurrencyMulti-producer
0 likes · 30 min read
Why Disruptor Beats Traditional Queues: Inside Java’s High‑Performance RingBuffer
Meituan Technology Team
Meituan Technology Team
Oct 1, 2016 · Backend Development

Analysis of Mutual Exclusion and Idempotency Issues in Distributed Systems and Their Solutions

The article examines how distributed systems face mutual‑exclusion and idempotency challenges, explains traditional thread and process synchronization, then details distributed‑lock techniques (e.g., Zookeeper, Redis, Tair, Cerberus) and global‑ID‑based idempotent services, emphasizing the importance of external storage, fault‑tolerance, and proper lock granularity for reliable high‑throughput applications.

IdempotencyJava concurrencyRedis
0 likes · 36 min read
Analysis of Mutual Exclusion and Idempotency Issues in Distributed Systems and Their Solutions