Tagged articles
JUC
23 articles · Page 1 of 1
This article provides a thorough, image‑rich overview of Java concurrency, covering the differences between concurrency and parallelism, thread lifecycle states, various ways to create threads, thread‑pool design and workflow, the Java Memory Model, and essential JUC utilities, all illustrated with code snippets and diagrams.
ConcurrencyJUCJava
0 likes · 8 min read

This guide compiles the most common Java thread‑pool interview questions, explains why and how thread pools are used, details the core parameters and execution flow of ThreadPoolExecutor, explores internal locks, usage patterns, monitoring, rejection policies, common pitfalls, and introduces the DynamicTp management framework.
BlockingQueueJUCJava
0 likes · 32 min read

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.
AQSFair LockJUC
0 likes · 19 min read

This article explains Java's Exchanger class, detailing its synchronization mechanism, internal source‑code structure, practical usage examples, and how it compares with other concurrency utilities such as CyclicBarrier, Semaphore, and SynchronousQueue.
ConcurrencyExchangerJUC
0 likes · 10 min read

This article explains Java 8's StampedLock—its optimistic and pessimistic read/write modes, internal state handling, source‑code walkthrough, typical usage scenarios, and a performance comparison with ReentrantLock and ReentrantReadWriteLock—providing concrete code examples and detailed analysis for developers.
ConcurrencyJUCJava
0 likes · 12 min read

This article explains the concepts, key features, internal implementation, and practical usage of Java's ReentrantReadWriteLock, illustrating how read and write locks interact, how fairness and lock downgrading work, and provides a complete code example with multithreaded readers and writers.
ConcurrencyJUCJava
0 likes · 12 min read

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.
ConcurrencyInterviewJUC
0 likes · 33 min read

This article explains how Java achieves lock‑free concurrency using CAS and volatile for optimistic locking, discusses its advantages and drawbacks such as the ABA problem and contention hotspots, and presents solutions including versioned CAS classes and contention‑reduction techniques provided by the JUC package.
CASConcurrencyJUC
0 likes · 6 min read

This article explains the fundamentals of Java threading, covering process vs thread differences, context switching, daemon and user threads, thread states, synchronization mechanisms, interruption handling, and deadlock detection with concrete code examples and visual illustrations.
ConcurrencyJUCJava
0 likes · 18 min read

This article introduces Java's java.util.concurrent (J.U.C) package, explains its lock mechanisms—including Lock, ReentrantLock, ReentrantReadWriteLock, and Condition—provides detailed code examples, and discusses lock types such as fair, non‑fair, and read/write locks for effective multithreaded synchronization.
ConditionJUCJava
0 likes · 16 min read

This article provides an in‑depth analysis of Java's AbstractQueuedSynchronizer (AQS), explaining its internal data structures, lock acquisition and release mechanisms for ReentrantLock and ReentrantReadWriteLock, and demonstrates how higher‑level concurrency utilities such as Condition, CountDownLatch, CyclicBarrier, and Semaphore are built on top of AQS.
AQSJUCJava
0 likes · 28 min read


JavaEdgeApr 27, 2021 · Backend Development
This article explains the core concepts of Java concurrency, comparing mutual exclusion and synchronization, detailing how JUC's Lock and Condition implement monitors, why Lock offers interruptible, timed, and non‑blocking acquisition, and how visibility and reentrancy are guaranteed through volatile state and Happens‑Before rules.
JUCJavaReentrantLock
0 likes · 9 min read

This article provides a comprehensive, systematic guide to Java concurrency, covering fundamental concepts, key keywords such as volatile, final, and synchronized, and an in‑depth exploration of the J.U.C framework including locks, atomic classes, concurrent collections, thread pools, and utility classes.
JUCJavaLocks
0 likes · 23 min read

This article provides an in-depth explanation of Java's AbstractQueuedSynchronizer (AQS) framework, covering its role in JUC concurrency utilities such as locks, semaphores, CountDownLatch, ReentrantReadWriteLock, and Condition, including template methods, state management, node structures, queue algorithms, and practical code examples.
AQSConcurrencyCondition
0 likes · 25 min read

The article presents a design for an asynchronous component that is monitorable, fault‑tolerant, and integrates with zero overhead, compares Akka, RxJava, and a custom JUC‑based implementation, and selects the latter—using extended Callables and a CountDownLatch—to track business units, handle timeouts, and provide fallback behavior.
ConcurrencyJUCJava
0 likes · 8 min read

This article provides a comprehensive overview of Java's concurrent queue implementations, explaining the differences between blocking and non‑blocking queues, their underlying mechanisms, typical use‑cases, and code examples for classes such as ArrayBlockingQueue, LinkedBlockingQueue, PriorityBlockingQueue, DelayQueue, SynchronousQueue, LinkedTransferQueue, and LinkedBlockingDeque.
BlockingQueueConcurrencyJUC
0 likes · 16 min read

This article categorizes the tools in java.util.concurrent, explains the six major groups of JUC utilities, dives deep into the design and behavior of various blocking and non‑blocking queues, shows their core methods, typical use‑cases, and provides code examples for practical implementation.
BlockingQueueJUCThreadPool
0 likes · 15 min read

This article provides a comprehensive analysis of Java's ThreadPoolExecutor, covering its underlying JUC synchronizer framework, core and non‑core thread handling, state management, key configuration parameters, and detailed walkthrough of critical source‑code methods such as execute, addWorker, and runWorker, supplemented with illustrative code examples.
AQSConcurrencyCoreThreadPool
0 likes · 30 min read

This article provides a comprehensive overview of Java's java.util.concurrent package, detailing its core components such as atomic classes, locks, collections, executors, tools, as well as an in‑depth explanation of the AbstractQueuedSynchronizer (AQS) framework, its fields, methods, and related concurrency utilities like FutureTask, BlockingQueue, ForkJoin, and work‑stealing algorithms.
AQSConcurrencyForkJoin
0 likes · 22 min read

This article explains why Java concurrency has a steep learning curve, introduces the JUC package and its core components, illustrates common pitfalls with queues and thread pools, and guides readers through the inner workings of AQS, locks, atomic classes, and advanced synchronizers.
JUCJavaLocks
0 likes · 11 min read

This article introduces the Java JUC concurrent collection classes, detailing the thread‑safe List and Set implementations, the concurrent Map variants, and the various Queue types, while providing diagrams and brief explanations of their usage and characteristics.
Concurrent CollectionsJUCJava
0 likes · 4 min read

This article explains the internal mechanics of Java's ConcurrentHashMap when a bucket’s linked list exceeds the TREEIFY_THRESHOLD, detailing how the structure is converted into a red‑black tree, the treeifyBin implementation, node insertion cases, rotation operations, and the supporting helper methods.
JUCRed-Black Treedata-structures
0 likes · 15 min read


21CTOOct 11, 2015 · Backend Development
This article dissects Java’s Executors utility, revealing how Executors.newFixedThreadPool creates a ThreadPoolExecutor, detailing constructor parameters, task execution flow, thread creation, queue handling, rejection policies, and worker lifecycle, giving readers a clear understanding of the internal mechanics behind Java’s thread pools.
ExecutorsJUCJava
0 likes · 14 min read
