Synchronization and locks

In Java, synchronization and locks are mechanisms used to ensure thread safety and prevent concurrent access to shared resources. They help in controlling the execution order of threads and avoiding race conditions.

1. Synchronization: Synchronization in Java is achieved using the synchronized keyword or by using synchronized blocks. The purpose of synchronization is to restrict multiple threads from executing a piece of code simultaneously, ensuring that only one thread can execute it at a time.

a) Synchronized methods:

public synchronized void synchronizedMethod() {
    // Synchronized code block
    // Only one thread can execute this method at a time
}

b) Synchronized blocks:

public void someMethod() {
    synchronized (lockObject) {
        // Synchronized code block
        // Only one thread can execute this block at a time
    }
}

2. Locks: Java provides the Lock interface and its implementations such as ReentrantLock and ReentrantReadWriteLock for more fine-grained control over synchronization. Locks provide additional capabilities compared to synchronized blocks, such as the ability to acquire and release locks at different points in the code and the ability to interrupt threads waiting for locks.

a) ReentrantLock:

import java.util.concurrent.locks.ReentrantLock;

ReentrantLock lock = new ReentrantLock();

public void someMethod() {
    lock.lock();
    try {
        // Critical section
    } finally {
        lock.unlock();
    }
}

b) ReentrantReadWriteLock:

import java.util.concurrent.locks.ReentrantReadWriteLock;

ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();

public void readMethod() {
    rwLock.readLock().lock();
    try {
        // Read data
    } finally {
        rwLock.readLock().unlock();
    }
}

public void writeMethod() {
    rwLock.writeLock().lock();
    try {
        // Write data
    } finally {
        rwLock.writeLock().unlock();
    }
}

Locks provide more flexibility than synchronized blocks but require explicit locking and unlocking, making it important to release the lock in a finally block to avoid deadlock scenarios.

Both synchronization and locks help in managing concurrent access to shared resources and ensure thread safety. The choice between them depends on the specific requirements of your application.