Optimizing Synchronization with Double-Checked Locking | CodeSignal Learn

Optimizing Synchronization with Double-Checked Locking | CodeSignal Learn

Optimizing Synchronization with Double-Checked Locking

Welcome back to our journey through Java Concurrency Essentials! In our previous lessons, we explored the volatile keyword and synchronization to maintain consistency in concurrent applications. In this lesson, we'll take a closer look at optimizing these techniques by learning about Double-Checked Locking —a pattern that combines volatile and synchronized in an efficient way to solve concurrency challenges while minimizing performance overhead. See how to apply these concepts through hands-on code examples.

What You'll Learn

By the end of this lesson, you will: Understand the potential drawbacks of basic synchronization when used in Singleton patterns. Learn how the Double-Checked Locking pattern optimizes synchronization. Implement a thread-safe Singleton using Double-Checked Locking. Understand the role of the volatile keyword within Double-Checked Locking. These concepts will help you build efficient, thread-safe applications that can manage shared resources effectively.

The Problem with Basic Synchronization in a Singleton

The Singleton pattern ensures that only one instance of a class is created throughout the lifecycle of an application. It is useful in managing shared resources like database connections or configuration settings. Let’s look at a simple, thread-safe implementation of a Singleton using synchronization: Java public class Singleton {private static Singleton instance; private Singleton() {// Initialization code} public static synchronized Singleton getInstance() {if (instance == null) {instance = new Singleton();} return instance;}} This implementation uses the synchronized keyword to ensure that the getInstance() method is thread-safe. This works well to maintain only one instance, but it comes with a drawback: Each time getInstance() is called, it has to acquire a lock even when the instance is already created. This leads to unnecessary synchronization, creating overhead that can slow down the performance of the application, especially when the method is frequently accessed. To address this problem, we can use Double-Checked Locking, which ensures thread safety without repeatedly acquiring the lock.

Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Singleton with Double-Checked Locking

Here is how Double-Checked Locking improves the basic Singleton implementation: Java public class Singleton {private static volatile Singleton instance; private Singleton() {// Initialization code} public static Singleton getInstance() {if (instance == null) { // First check without synchronization synchronized (Singleton.class) { // Synchronized block if (instance == null) { // Second check with synchronization instance = new Singleton(); // Create the instance}}} return instance;}} Double-Checked Locking involves several key elements: The volatile declaration ensures that the instance variable is always read from main memory. This prevents issues like partially constructed objects becoming visible to other threads, which can happen if the JVM reorders instructions. The first check (if (instance == null)) happens without synchronization. This means that once the Singleton is created, accessing it will be very efficient since no locking is required. The synchronized block only comes into play when instance is null, ensuring that only one thread can create the Singleton instance. The second check (if (instance == null)) within the synchronized block is crucial. This is to ensure that if multiple threads reach the synchronized block at the same time, only one will actually create the instance. Double-Checked Locking optimizes performance by minimizing the use of synchronization, which is only needed during the initial instance creation.

The Main Method

Let’s see Double-Checked Locking in action in a multi-threaded environment: Java public class Main {public static void main(String[] args) {Runnable singletonTest = () -> {Singleton instance = Singleton.getInstance(); System.out.println("Singleton instance: " + instance);}; Thread t1 = new Thread(singletonTest); Thread t2 = new Thread(singletonTest); Thread t3 = new Thread(singletonTest); Thread t4 = new Thread(singletonTest); t1.start(); t2.start(); t3.start(); t4.start(); try {t1.join(); t2.join(); t3.join(); t4.join();} catch (InterruptedException e) {e.printStackTrace();}}} In this example, we create four threads (t1, t2, t3, t4) that concurrently call Singleton.getInstance() . Each thread attempts to access the Singleton instance, and Double-Checked Locking ensures that only one instance is created without redundant locking overhead. The Runnable Definition defines a task that calls Singleton.getInstance() and prints the instance reference. Thread Creation and Execution : Each thread runs the task concurrently, showing that even with multiple threads attempting to create the Singleton, only one instance is created. Thread Join : The join() method ensures that the main thread waits for all threads to complete execution.