23. Synchronization and Locks in Java

23. Synchronization and Locks in Java

Concurrent programming in Java is an advanced and crucial topic for developing robust and efficient applications. However, with the execution of multiple threads accessing shared resources, challenges arise related to data consistency and coordination between threads. To deal with these challenges, Java provides synchronization and locking mechanisms.

The Problem of Competition

When multiple threads operate on shared data without proper synchronization, race conditions may occur, where the execution results depend on the non-deterministic order in which the threads are executed. This can lead to unpredictable behavior and bugs that are difficult to reproduce and fix.

Synchronization Mechanisms

To avoid race conditions, Java offers synchronization mechanisms that allow you to control access to shared resources. The main construct for synchronization in Java is the synchronized keyword, which can be used to synchronize a block of code or an entire method.

Synchronized Methods

When a method is declared as synchronized, it guarantees that only one thread at a time can execute it on an instance of the class. If the method is static, the blocking is at the class level, not the instance level.

public synchronized void synchronized method() {
    // Code that manipulates shared resource
}

Synchronized Blocks

Instead of synchronizing an entire method, you can synchronize just a critical section of code using a synchronized block. This is done by specifying a lock object, on which the lock is held.

public void metodoComBlocoSincronizado() {
    synchronized (this) {
        // Critical section of the code
    }
}

Inherent Monitors and Blocks

In Java, each object has an inherent lock or monitor, which is used to implement synchronization. When a thread enters a synchronized method or block, it acquires the lock associated with the object or class. Other threads attempting to access the same synchronized block or method will block until the current thread releases the lock.

Explicit Locks

In addition to inherent locks, the Java Concurrency API (java.util.concurrent) provides a series of explicit locking classes that offer more flexibility and control. The classes ReentrantLock, ReadWriteLock and StampedLock are some examples.

import java.util.concurrent.locks.ReentrantLock;

public class ExampleLock {
    private final ReentrantLock lock = new ReentrantLock();

    public void methodComLock() {
        lock.lock();
        try {
            // Code protected by lock
        } finally {
            lock.unlock();
        }
    }
}

Explicit locks offer additional features, such as the ability to attempt to acquire a lock without waiting indefinitely (tryLock), the ability to interrupt a thread while it waits for a lock (lockInterruptibly< /code>) and the ability to check whether the lock is being held (isLocked).

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ExampleCondition {
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();

    public void awaitCondicao() throws InterruptedException {
        lock.lock();
        try {
            // Wait until the condition is satisfied
            condition.await();
        } finally {
            lock.unlock();
        }
    }

    public void signalCondition() {
        lock.lock();
        try {
            // Signals a thread that is waiting for the condition
            condition.signal();
        } finally {
            lock.unlock();
        }
    }
}