What is Thread Synchronization in Java?

In multithreaded programming, synchronization is a crucial mechanism that ensures the safe and consistent access of multiple threads to shared resources. It prevents race conditions, which occur when threads compete to modify the same data, potentially leading to unexpected or incorrect results.

How Synchronization Works in Java

There are several ways to achieve synchronization in Java:

Synchronized Methods

By using the synchronized keyword, you can ensure that only one thread can execute a synchronized method of an object at a time. When a thread enters a synchronized method, it acquires the intrinsic lock (also known as a monitor lock) of the object, and other threads trying to access synchronized methods of the same object are blocked until the lock is released.

class Counter { private int count = 0; public synchronized void increment() { count++; } public synchronized int getCount() { return count; } }

Synchronized Blocks

You can synchronize specific blocks of code rather than entire methods using synchronized blocks. This allows finer control over synchronization and can improve performance in some cases.

class SharedResource { private int value = 0; public void updateValue() { synchronized (this) { // synchronized block value++; } } }

Choosing Between Synchronized Methods and Blocks

  1. Use synchronized methods when you want to synchronize access to all operations within the method. It's simpler and promotes better encapsulation.
  2. Use synchronized blocks when you only need to synchronize a specific portion of your code within a method. This can provide finer-grained control and potentially improve performance.

Static Synchronization

Static methods can also be synchronized, using the class's intrinsic lock instead of the object's lock.

class SharedResource { private static int count = 0; public static synchronized void increment() { count++; } }

Synchronization Using Locks

Java provides the Lock interface and its implementations such as ReentrantLock for more flexible synchronization. Unlike intrinsic locks, locks provide more control over the locking and unlocking process, including support for conditions and timeout.

import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; class SharedResource { private int count = 0; private Lock lock = new ReentrantLock(); public void increment() { lock.lock(); try { count++; } finally { lock.unlock(); } } }

Synchronization Using volatile Keyword

The volatile keyword ensures that variables are always read from and written to main memory, rather than from thread-specific caches. While volatile variables provide visibility guarantees, they do not provide atomicity like synchronized methods or blocks.

class SharedResource { private volatile int value = 0; public void updateValue() { value++; } }

Thread-Unsafe Counter

Consider a simple counter class that's incremented by multiple threads:

public class UnsafeCounter { private int count = 0; public void increment() { count++; // This line is not thread-safe } }

If multiple threads call increment() concurrently, the outcome is unpredictable. The increment operation might not be atomic (meaning it's not guaranteed to be executed as a single, indivisible step). This could lead to a race condition where the final value of count is less than the expected number of increments due to interleaving of instructions from different threads.

Synchronized Counter

To make the counter thread-safe, we can synchronize the increment() method:

public class SafeCounter { private int count = 0; public synchronized void increment() { count++; } }

Now, only one thread can execute the increment() method at a time, ensuring that the increment operation is performed atomically, and the final value of count will be accurate.

A more complex example:

Consider a scenario where multiple threads are updating a shared counter:

class Counter { private int count = 0; public synchronized void increment() { count++; } public synchronized int getCount() { return count; } } public class Main { public static void main(String[] args) { Counter counter = new Counter(); // Multiple threads incrementing the counter Thread thread1 = new Thread(() -> { for (int i = 0; i < 1000; i++) { counter.increment(); } }); Thread thread2 = new Thread(() -> { for (int i = 0; i < 1000; i++) { counter.increment(); } }); thread1.start(); thread2.start(); try { thread1.join(); thread2.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Final Count: " + counter.getCount()); // Expected output: 2000 } }

In this example, without synchronization, the final count might not be 2000 due to race conditions. By making the increment method synchronized, we ensure that only one thread can access it at a time, preventing such issues.

Additional Considerations

  1. Deadlocks: Synchronization can introduce the possibility of deadlocks, where two or more threads are permanently waiting for each other to release locks. Be cautious when designing your synchronization strategy to avoid deadlocks.
  2. Performance Overhead: Synchronization adds some overhead due to lock acquisition and release. Use it judiciously and only for critical sections of code that require data consistency.

Alternatives to Synchronization

  1. Concurrent Collections: Java provides thread-safe collection classes (e.g., ConcurrentHashMap, CopyOnWriteArrayList) that you can use instead of synchronizing your own data structures.
  2. Semaphores: Semaphores are signaling mechanisms that can be used to control access to a limited number of resources.


Synchronization ensures that only one thread can access a shared resource at a time, preventing race conditions and maintaining data consistency. This can be achieved through synchronized methods, synchronized blocks, static synchronization, or by using locks such as ReentrantLock. Synchronization is essential for multi-threaded applications to ensure thread safety and prevent data corruption.