Chapter 14: Building Custom Synchronizers

Back> 

Chapter 14: Building Custom Synchronizers

Java provides many powerful concurrency primitives like ReentrantLock, Semaphore, and CountDownLatch, but sometimes those tools are not a perfect fit for the problem at hand. Chapter 14 of Java Concurrency in Practice explores how to build custom synchronizers, giving you complete control over thread coordination using lower-level APIs such as Condition variables and AbstractQueuedSynchronizer (AQS).

Understanding the Concepts

• State-based preconditions: Conditions under which a thread may proceed, such as "buffer is not full" or "latch is open."
• Condition predicates: Logical expressions evaluated against shared state, e.g., while (isFull()) wait().
• Condition queues: Thread queues managed by the monitor (intrinsic) or explicitly via Condition objects.
• Missed signals: Occur when a notification happens before a thread starts waiting — can be avoided by checking predicates in a loop.
• Notification: Signaling threads to recheck the predicate. In intrinsic monitors, this is done via notify() or notifyAll().
• Explicit condition objects: Created from Lock.newCondition(), allowing multiple wait-sets and precise control.
• AQS (AbstractQueuedSynchronizer): A low-level framework for building efficient synchronizers by managing atomic state and a wait queue.

From Naive to Robust: Bounded Buffer Evolution

The bounded buffer problem — where producers must wait when the buffer is full and consumers must wait when it's empty — is a classic case for custom synchronizer design. Let’s walk through its evolution:

• BaseBoundedBuffer.java: A shared base class managing buffer logic with synchronized helper methods.
• GrumpyBoundedBuffer.java: Balks when conditions are not met — throws exceptions if the buffer is full or empty.
• SleepyBoundedBuffer.java: Polls with Thread.sleep() — wasteful but simple blocking strategy.
• BoundedBuffer.java: Uses intrinsic condition queues with synchronized, wait(), and notifyAll().
• ConditionBoundedBuffer.java: Introduces explicit Lock and Condition objects for clean signaling and reduced contention.

Comparing Condition Mechanisms

Feature	Intrinsic Condition Queue (synchronized)	Explicit Condition Object (Lock.newCondition())
Multiple wait sets	❌ No (single wait set)	✅ Yes
Interruptible waits	✅ Yes	✅ Yes
Timed waits	✅ Yes	✅ Yes
Fairness control	❌ No	✅ With fair locks
Signal specific condition	❌ No (must notify all)	✅ Yes

Custom Synchronizers with AQS

When you need full control over blocking, waking, and state transitions, AbstractQueuedSynchronizer (AQS) is the foundation. It manages a FIFO queue and provides atomic state control for shared and exclusive modes.

• OneShotLatch.java: A custom one-time latch using AQS shared mode to unblock all waiting threads once signaled.

Other Custom Primitives

You can also simulate classic synchronization primitives using locks and conditions:

• ThreadGate.java: A reclosable gate implemented with synchronized, allowing multiple threads to await a phase change.
• SemaphoreOnLock.java: A counting semaphore built with ReentrantLock and a condition variable (not how real Semaphore works, but educational).

Relevance in the Loom Era

With Java Loom and virtual threads, developers are encouraged to write simpler, more natural concurrent code — often returning to synchronized and blocking I/O. However, custom synchronizers remain relevant:

• Advanced coordination like barriers, staged execution, or throttling still benefit from custom synchronizers.
• Virtual threads can block cheaply, but they still need synchronization — especially for fairness or visibility guarantees.
• AbstractQueuedSynchronizer, Lock, and Condition are Loom-compatible and often used in hybrid models.

In short, Loom expands our toolbox — it doesn’t remove the need for these low-level synchronization constructs. For fine-tuned control and high-concurrency scenarios, building your own synchronizers remains a powerful and relevant skill.

Conclusion

Chapter 14 empowers you to move beyond standard concurrency utilities and build synchronization mechanisms tailored to your application's behavior. From evolving bounded buffers to writing custom latches and semaphores, the ability to construct your own synchronizers gives you unmatched flexibility and insight into how thread coordination truly works — both today and in the future with Loom.