Double-checked locking Design Pattern-Out-of-order writes

Master Java Concurrency & Design Patterns!

Subscribe to Ram N Java for clear, beginner-friendly explanations of complex Java concepts.

👉 Subscribe Now on YouTube

Understanding the Out-of-Order Writes Issue

The Double-Checked Locking pattern is widely cited as an optimization technique for lazy-loading Singleton instances in multi-threaded environments. However, without careful handling, it can fail subtly due to a classic concurrency hazard known as out-of-order writes.

1. The Double-Checked Locking Setup

In a standard double-checked locking idiom, thread safety is attempted with two null checks and a synchronized block:

• The first check verifies if the instance is null without taking a lock.
• If null, the thread enters a synchronized block and checks once more.
• If still null, it initializes the instance: instance = new Singleton();

2. What Happens During Object Creation?

When the line instance = new Singleton(); executes, the underlying JVM performs three distinct steps:

1. Allocates memory space for the Singleton object.
2. Executes the constructor to initialize fields inside that memory.
3. Assigns the memory reference to the instance variable.

3. How Out-of-Order Writes Cause Bugs

Due to instruction reordering allowed by the Java Memory Model (JMM) for optimization:

• Reordering: Step 3 can execute before Step 2. Memory is assigned to instance before constructor execution completes.
• Thread Race: If Thread A allocates memory and publishes the reference, Thread B may arrive at the first null check.
• Partially Initialized State: Thread B sees that instance is not null, skips synchronization, and immediately consumes the object—even though its fields are not yet initialized!

Because of this fundamental flaw under naive implementations, double-checked locking is often classified as an anti-pattern unless explicit memory-barrier guarantees (like the volatile modifier) are used.

Recommended Related Videos from Ram N Java

Deepen your multithreading and design pattern knowledge with these related tutorials:

• Double-Checked Locking Design Pattern: Basics and Principles
• Double-Checked Locking Design Pattern: Implementation Explained
• Read-Write Lock Design Pattern Overview

---

Click here to watch in Youtube : https://www.youtube.com/watch?v=pMztRT1PraA

Click the below Image to Enlarge

Double-checked locking Design Pattern-Out-of-order writes

See also:

All Design Patterns Links

Double-checked locking Design Pattern - Implementation

Master Java Multithreading & Patterns!

Subscribe to Ram N Java for clean, beginner-friendly software architecture tutorials.

👉 Subscribe Now on YouTube

Implementing Double-Checked Locking in Java

Synchronizing an entire method call like getInstance() creates a performance bottleneck because every single thread has to acquire a lock, even after the singleton object has already been created. The Double-Checked Locking Design Pattern aims to solve this by acquiring the lock only when initialization is truly required.

1. The Implementation Structure

Instead of placing the synchronized keyword at the method level, synchronization is moved inside the method with two checks:

• First Check: Verify if instance == null without locking. If it is already initialized, return it immediately without overhead.
• Synchronized Block: If instance is null, enter a synchronized block to ensure only one thread can proceed.
• Second Check: Check again if instance == null inside the synchronized block before allocating the object.

2. Step-by-Step Thread Execution Flow

Here is what happens when two threads (Thread A and Thread B) enter simultaneously:

1. Thread A arrives: Evaluates instance == null (true) and acquires the lock on the synchronized block.
2. Thread B arrives: Evaluates instance == null (true) and attempts to enter the synchronized block, but gets blocked because Thread A holds the lock.
3. Thread A creates instance: Re-checks instance == null inside the block, initializes the new object, exits the synchronized block, and returns the reference.
4. Thread B resumes: Enters the synchronized block, evaluates the second check instance == null (now false!), skips initialization, and safely returns the existing instance created by Thread A.

3. The Reality: Why It Can Fail

While the logic appears foolproof in theory, in practice it can break without proper memory barriers:

• Out-of-Order Writes: The Java Memory Model allows compilers and processors to reorder instructions for performance. An object reference can be assigned before the constructor finishes executing.
• Anti-Pattern Classification: Because unsynchronized reader threads can see partially initialized objects, double-checked locking is considered an anti-pattern unless used with the volatile keyword.

Recommended Related Videos from Ram N Java

Explore these multithreading tutorials to learn more about synchronization and locking:

• Double-Checked Locking Design Pattern: Basics and Principles
• Lock Design Pattern: Ensuring Synchronization in Multithreaded Applications
• Read-Write Lock Design Pattern Overview

---

Click here to watch in Youtube : https://www.youtube.com/watch?v=nL2n_NCl7TA

Click the below Image to Enlarge

Double-checked locking Design Pattern - Implementation

See also:

All Design Patterns Links