Synchronization

Synchronization is a core concept in Java multithreading that ensures controlled access to shared resources. It prevents multiple threads from interfering with each other when reading or modifying shared data, ensuring thread safety and data consistency.

What is Synchronization in java?

Synchronization is a mechanism that coordinates thread execution in Java so that only one thread at a time can access a critical section of code that manipulates shared resources.

• A critical section is the part of code where shared data is accessed or modified.
• Synchronization ensures atomicity and consistency of shared data.

Why is Synchronization Needed?

In multithreaded programs:

• Multiple threads may access and modify shared data simultaneously.
• Without synchronization, operations like count++ are not atomic.
• This can cause race conditions, data corruption, and unpredictable behavior.

Example:

Two threads increment a shared counter:

Without synchronization, the expected value is lost.

Types of Synchronization Based on Scope

1. Process Synchronization

Process synchronization is a technique used to coordinate multiple processes (independent programs running on the OS) so they can share resources safely without conflicts.

Key Points:

• Happens between processes, not threads.
• Ensures that shared resources like files, memory, or databases are accessed safely.
• OS provides tools like semaphores, mutexes, message queues, monitors.
• Each process has its own memory space; synchronization often relies on Inter-Process Communication (IPC).

Solution using a file lock (Java NIO example):

import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;

publicclassProcessSyncExample {
publicstaticvoidmain(String[] args)throws Exception {
try (RandomAccessFilefile=newRandomAccessFile("shared.txt","rw");
FileChannelchannel= file.getChannel()) {

// Try to acquire an exclusive lock on the file
try (FileLocklock= channel.lock()) {
                System.out.println("File locked by process: " + Thread.currentThread().getId());
                file.writeUTF("Writing safely to file by " + Thread.currentThread().getId());
                Thread.sleep(2000);// simulate processing time
            }// lock released automatically
        }
    }
}

✅ Explanation:

• The FileLock ensures only one process at a time can write to the file.
• If another program/process tries to lock the file, it must wait until the first releases it.

2. Thread Synchronization

Thread synchronization is used to coordinate multiple threads within a single process (JVM) so that shared data is accessed safely.

Key Points:

• Happens inside a single process.
• Threads share the same memory space, so race conditions can occur.
• Java provides built-in support using:
  • synchronized keyword (methods or blocks)
  • Locks (ReentrantLock, ReadWriteLock)
  • Atomic variables (AtomicInteger, AtomicLong)
  • wait(), notify(), notifyAll() for thread communication

Solution using synchronized method:

classBankAccount {
privateintbalance=100;

publicsynchronizedvoidwithdraw(int amount) {
if (balance >= amount) {
            System.out.println(Thread.currentThread().getName() +" is withdrawing " + amount);
            balance -= amount;
            System.out.println("New balance: " + balance);
        }else {
            System.out.println(Thread.currentThread().getName() +" insufficient balance");
        }
    }

publicintgetBalance() {
return balance;
    }
}

publicclassThreadSyncExample {
publicstaticvoidmain(String[] args) {
BankAccountaccount=newBankAccount();

Runnabletask= () -> account.withdraw(50);

Threadt1=newThread(task,"Thread-1");
Threadt2=newThread(task,"Thread-2");

        t1.start();
        t2.start();
    }
}

✅ Explanation:

• synchronized ensures only one thread can execute withdraw() at a time.
• Prevents race conditions and keeps the balance correct.

Comparison: Process vs Thread Synchronization

Ways to Achieve Synchronization in Java

Java provides multiple mechanisms to ensure that shared resources are accessed safely in multithreaded programs:

1. Synchronized Methods

• Declaring a method with the synchronized keyword ensures that only one thread at a time can execute that method for the same object.
• Locks are automatically acquired on the object (this) for instance methods or the Class object for static methods.
• Simple and easy to implement but can be coarse-grained, potentially reducing performance if the entire method doesn’t need synchronization.

Example:

classCounter {
privateintcount=0;

publicsynchronizedvoidincrement() {
        count++;
    }
}

2. Synchronized Blocks

• Provides fine-grained control by locking only a portion of the method (critical section).
• Reduces contention and improves performance compared to synchronizing the entire method.
• Locks can be applied on any object, not just this.

Example:

classCounter {
privateintcount=0;

publicvoidincrement() {
synchronized (this) {// only this block is synchronized
            count++;
        }
    }
}

3. Static Synchronization

• Used for static methods or class-level shared resources.
• Locks are acquired on the Class object, ensuring that only one thread can execute any static synchronized method of the class at a time.

Example:

classCounter {
privatestaticintcount=0;

publicstaticsynchronizedvoidincrement() {
        count++;
    }
}

4. Explicit Locks (ReentrantLock, ReadWriteLock)

• Provides more flexibility than the synchronized keyword.
• Features like fairness, tryLock, and interruptible locks are available.
• Developers manually acquire and release the lock, giving more control over concurrency behavior.

Example with ReentrantLock:

import java.util.concurrent.locks.ReentrantLock;

classCounter {
privateintcount=0;
privateReentrantLocklock=newReentrantLock();

publicvoidincrement() {
        lock.lock();
try {
            count++;
        }finally {
            lock.unlock();
        }
    }
}

5. Atomic Classes (AtomicInteger, AtomicLong)

• Part of java.util.concurrent.atomic.
• Provides lock-free, thread-safe operations for single variables.
• Operations like incrementAndGet() are atomic, meaning they execute completely without interference from other threads.

Example:

import java.util.concurrent.atomic.AtomicInteger;

classCounter {
privateAtomicIntegercount=newAtomicInteger(0);

publicvoidincrement() {
        count.incrementAndGet();// atomic operation
    }
}

Types of Synchronization

1. Method-Level Synchronization

This synchronizes the entire method, so only one thread can execute it on the same object at a time.

Syntax:

publicsynchronizedvoidincrement() {
    count++;
}

• Locks the object instance for instance methods.
• For static synchronized methods, locks the class object.
• Simple to implement but may block threads unnecessarily if only part of the method needs synchronization.

2. Block-Level Synchronization

Instead of locking the whole method, you can synchronize only a specific block of code inside the method.

Syntax:

publicvoidincrement() {
synchronized(this) {// Lock on the current object
        count++;
    }
}

• More efficient than method-level synchronization.
• Can lock on any object, not just this.
• Useful when only a critical section needs synchronization.

3. Static Synchronization

Used for static methods or blocks to lock class-level resources rather than object-level resources.

Syntax:

publicstaticsynchronizedvoidstaticIncrement() {
    staticCount++;
}

Or using a block:

synchronized(MyClass.class) {
    staticCount++;
}

• Ensures class-level lock.
• All threads share the same class-level lock regardless of the object instance.

4. Object-Level Synchronization

You can explicitly synchronize on any object, not necessarily this.

Syntax:

Objectlock=newObject();

publicvoidincrement() {
synchronized(lock) {
        count++;
    }
}

• Allows fine-grained control over which object to lock.
• Multiple locks can coexist in the same class to increase concurrency.

5. Synchronized Collections

Java provides built-in synchronized versions of collections in java.util.Collections.

List<String> list = Collections.synchronizedList(newArrayList<>());

• Simplifies thread-safe collection access.
• Iteration still requires manual synchronization.

6. Explicit Locks (java.util.concurrent.locks)

From Java 5 onward, you can use Lock interface for more flexible synchronization.

ReentrantLocklock=newReentrantLock();

lock.lock();
try {
    count++;
}finally {
    lock.unlock();
}

• Supports fairness, tryLock(), and interruptible locking.
• More advanced control than synchronized.

Summary Table:

How Synchronization Works

• When a thread enters a synchronized method or block, it acquires a lock on the object or class.
• Other threads attempting to enter the same synchronized code must wait until the lock is released.
• After execution, the thread releases the lock, allowing other threads to proceed.

Example – Synchronized Method:

classCounter {
privateintcount=0;

publicsynchronizedvoidincrement() {
        count++;
    }

publicsynchronizedintgetCount() {
return count;
    }
}

Example – Synchronized Block:

classCounter {
privateintcount=0;

publicvoidincrement() {
synchronized (this) {// critical section
            count++;
        }
    }
}

Object-level vs Class-level Lock

Example:

// Object-level lock
Counterc1=newCounter();
Counterc2=newCounter();
c1.increment();// Thread locks only c1
c2.increment();// Thread locks only c2

// Class-level lock
Counter.incrementStatic();// Locks class, other threads must wait

Key Points About Synchronization

• Synchronization prevents race conditions and ensures thread-safe operations.
• Only one thread can hold a lock at a time.
• Overuse of synchronization can lead to performance overhead.
• Mismanaged locks can cause deadlocks, where threads wait indefinitely.
• Prefer synchronized blocks over methods when possible for better performance.

Real-Life Analogy

Think of a single-lane bridge:

• Only one car (thread) can cross at a time.
• Others must wait in line until the bridge is free.
• Without this rule, collisions (data corruption) happen.

Summary

• Synchronization is critical for thread safety in Java.
• It ensures exclusive access to shared resources.
• Achieved via synchronized methods, blocks, class-level locks, or concurrency utilities.
• Proper use prevents race conditions, ensures data consistency, and makes multithreaded programs predictable and reliable.