Locks

In multithreaded Java applications, multiple threads often try to access shared resources at the same time. This can lead to race conditions, data inconsistency, and unpredictable behavior.

To handle this safely, Java provides Locks — powerful synchronization mechanisms that offer more control and flexibility than the traditional synchronized keyword.

Locks are part of the Java Concurrency API and are available in the java.util.concurrent.locks package.

What is a Lock in Java?

A Lock is a mechanism that allows only one thread at a time to access a critical section of code.

• A thread must acquire the lock before accessing shared data
• Other threads must wait until the lock is released
• Once released, another waiting thread can acquire the lock

Think of a lock like a room key — only one person (thread) can enter at a time.

Why Use Locks Instead of synchronized?

While synchronized works well, Locks are more powerful and flexible.

Problems with synchronized

• No try-lock option
• No timeout control
• Difficult to interrupt waiting threads

Advantages of Locks

• Try to acquire a lock without waiting
• Specify timeout while waiting
• Interruptible lock acquisition
• Fairness policies (first-come, first-served)
• Better performance in complex scenarios

Types of Locks in Java

Java provides different types of Locks to handle various multithreading scenarios. Each lock type is designed to solve a specific concurrency problem efficiently.

1. Intrinsic Locks (synchronized)

Intrinsic locks are the default locks provided by Java.

Key Points

• Every Java object has an intrinsic lock
• Managed automatically by the JVM
• Used with the synchronized keyword
• Lock is released automatically when the block or method exits

Example

synchronized (this) {
// critical section
}

When to Use

• Simple synchronization needs
• Small applications
• Easy and readable code

2. ReentrantLock

ReentrantLock is the most commonly used explicit lock in Java.

Why Reentrant?

A thread holding the lock can acquire it again without causing a deadlock.

Features

• tryLock() support
• Timeout while waiting
• Interruptible lock acquisition
• Fair and unfair locking options

Example

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

public class ReentrantLockExample {

    private final Lock lock = new ReentrantLock();
    private int count = 0;

    public void increment() {
        lock.lock();
        try {
            count++;
            System.out.println(Thread.currentThread().getName() +
                               " count = " + count);
        } finally {
            lock.unlock(); // always release lock
        }
    }
}

When to Use

• Need more control than synchronized
• Complex multithreaded systems

3. ReadWriteLock

ReadWriteLock separates read and write operations.

How It Works

• Multiple threads can read at the same time
• Only one thread can write
• No reading while writing

Implementation

ReentrantReadWriteLock

Common Implementation

ReadWriteLocklock=newReentrantReadWriteLock();

ReadWriteLock Example

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

publicclassReadWriteLockExample {

privatefinalReadWriteLocklock=newReentrantReadWriteLock();
privateintdata=0;

publicvoidreadData() {
        lock.readLock().lock();
try {
            System.out.println("Reading data: " + data);
        }finally {
            lock.readLock().unlock();
        }
    }

publicvoidwriteData(int value) {
        lock.writeLock().lock();
try {
            data = value;
            System.out.println("Writing data: " + data);
        }finally {
            lock.writeLock().unlock();
        }
    }
}

When to Use

• Read-heavy applications
• Caching systems
• Database-like operations

4. StampedLock (Java 8+)

StampedLock is an advanced and high-performance lock.

Key Features

• Supports optimistic locking
• Reduces blocking
• Faster than ReadWriteLock in many cases

Important Note

• Not reentrant
• More complex to use
• No Condition Objects

StampedLock Example (Optimistic Read)

import java.util.concurrent.locks.StampedLock;

publicclassStampedLockExample {

privateintdata=10;
privatefinalStampedLocklock=newStampedLock();

publicintreadData() {
longstamp= lock.tryOptimisticRead();
intcurrentData= data;

if (!lock.validate(stamp)) {
            stamp = lock.readLock();
try {
                currentData = data;
            }finally {
                lock.unlockRead(stamp);
            }
        }
return currentData;
    }

publicvoidwriteData(int value) {
longstamp= lock.writeLock();
try {
            data = value;
        }finally {
            lock.unlockWrite(stamp);
        }
    }
}

When to Use

• Your application has many read operations
• Write operations are rare
• You need maximum throughput
• You are building high-performance or large-scale systems

5. Fair Lock

A fair lock ensures threads acquire the lock in the order they requested it.

How Fair Lock Works

• Threads are placed in a queue
• The thread waiting the longest gets the lock first
• Prevents one thread from repeatedly jumping ahead of others

Fair Lock Example

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

Locklock=newReentrantLock(true);// fair lock

Passing true to the ReentrantLock constructor enables fairness.

When to Use a Fair Lock

Use a fair lock when:

• All threads must get equal execution opportunity
• Starvation must be avoided
• Execution order matters more than performance

6. Unfair Lock (Default)

An Unfair Lock does not guarantee that threads will acquire the lock in the order they requested it. A thread can jump ahead of others if the lock becomes available.

How Unfair Lock Works

• Threads are not queued strictly
• A thread may acquire the lock immediately if it finds it available
• Waiting threads may be bypassed by newly arrived threads

Unfair Lock Example

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

Locklock=newReentrantLock();// unfair lock (default)

When to Use an Unfair Lock

Use an unfair lock when:

• Performance is more important than fairness
• Tasks are short and fast
• Starvation risk is acceptable
• High throughput is required

7. Spin Lock (Conceptual)

A Spin Lock is a locking mechanism where a thread continuously checks (spins) to see if a lock is available instead of going into a blocked or sleeping state.

How a Spin Lock Works

1. Thread requests the lock
2. If the lock is unavailable, the thread keeps checking repeatedly
3. Once the lock is released, the spinning thread acquires it immediately

This approach avoids thread suspension but consumes CPU cycles.

When to Use Spin Lock (Conceptually)

Use a spin lock approach when:

• Lock is held for a very short duration
• Context switching cost is higher than spinning
• Running on multi-core CPUs
• High-performance, low-latency systems

Key Methods of Lock Interface

The Lock interface in Java provides advanced locking mechanisms beyond the basic synchronized keyword. These methods allow fine-grained control over thread synchronization.

1. lock()

Acquires the lock. If the lock is not available, the thread waits until it becomes free. Always use it inside a try-finally block to ensure the lock is released.

Locklock=newReentrantLock();

lock.lock();// acquire lock
try {
    System.out.println("Critical section executed by " + Thread.currentThread().getName());
}finally {
    lock.unlock();// release lock
}

2. unlock()

Releases the lock. It should always be called in the finally block to prevent deadlocks, ensuring other threads can acquire the lock safely.

3. tryLock()

Attempts to acquire the lock without waiting. Returns true if successful, otherwise false. This is useful when you don’t want threads to block indefinitely.

if (lock.tryLock()) {
try {
        System.out.println("Lock acquired, performing task");
    }finally {
        lock.unlock();
    }
}else {
    System.out.println("Could not acquire lock, skipping task");
}

4. tryLock(long time, TimeUnit unit)

Tries to acquire the lock within a specified timeout. Returns true if the lock is acquired in time, otherwise false. This helps avoid long waits and potential deadlocks.

if (lock.tryLock(2, TimeUnit.SECONDS)) {
try {
        System.out.println("Lock acquired within 2 seconds");
    }finally {
        lock.unlock();
    }
}else {
    System.out.println("Timeout: Could not acquire lock");
}

5. lockInterruptibly()

Acquires the lock unless the thread is interrupted while waiting. Throws InterruptedException if interrupted. This is useful for gracefully cancelling threads that are waiting for a lock.

try {
    lock.lockInterruptibly();
try {
        System.out.println("Lock acquired with interruptible waiting");
    }finally {
        lock.unlock();
    }
}catch (InterruptedException e) {
    System.out.println("Thread was interrupted while waiting for the lock");
}

6. newCondition()

Returns a Condition object associated with the lock. Conditions allow threads to wait and signal in a controlled way, similar to wait() and notify() in synchronized blocks, but more flexible.

Locklock=newReentrantLock();
Conditioncondition= lock.newCondition();

lock.lock();
try {
    System.out.println("Thread is waiting for condition");
    condition.await();// thread waits here
    System.out.println("Thread resumed after signal");
}catch (InterruptedException e) {
    e.printStackTrace();
}finally {
    lock.unlock();
}

// Another thread can signal
lock.lock();
try {
    condition.signal();
}finally {
    lock.unlock();
}

Important Rule: Always Unlock in finally Block

When using explicit locks like ReentrantLock, it’s critical to always release the lock. Failing to do so can cause deadlocks where other threads wait forever.

Example

lock.lock();// Acquire the lock
try {
// Critical section: only one thread executes here at a time
}finally {
    lock.unlock();// Always release the lock
}

Why this is important:

• Prevents deadlocks – other threads can continue execution.
• Ensures lock is always released, even if an exception occurs.
• Promotes safe and predictable multithreaded behavior.

tryLock() Example (Non-Blocking Lock)

The tryLock() method lets a thread attempt to acquire a lock without waiting, preventing blocking and improving performance in high-concurrency situations.

if (lock.tryLock()) {  // Attempt to acquire lock
    try {
        System.out.println("Lock acquired");
        // Critical section code
    } finally {
        lock.unlock();  // Always release the lock
    }
} else {
    System.out.println("Could not acquire lock");  // Lock not available
}

Key Benefits of tryLock()

• Non-blocking behavior – thread can proceed if lock is not available.
• Useful for timeout-based or optional operations.
• Helps avoid deadlocks in complex systems.

How Locks Work (Flow)

Locks control access to shared resources in multithreaded Java applications. Here’s how they work:

1. Thread Requests a Lock: A thread wants to enter a critical section and requests the lock.
2. Lock Acquisition: If the lock is available, the thread acquires it immediately.
3. Other Threads Wait: Threads that request the same lock while it’s held wait until it becomes free.
4. Thread Executes Critical Section: The thread holding the lock performs its critical work safely.
5. Lock Released: Once the work is done, the thread releases the lock.
6. Waiting Thread Acquires Lock: One of the waiting threads acquires the lock and proceeds to execute its task.

Best Practices for Using Locks

• Always unlock in a finally block
• Keep critical sections short
• Avoid nested locks (deadlock risk)
• Use ReadWriteLock for read-heavy systems
• Use tryLock() when waiting is dangerous
• Prefer synchronized for simple cases

Locks vs synchronized

Both synchronized and Lock are used to control access to shared resources in multithreaded applications. However, Locks provide more flexibility and advanced control.

Difference Between ReentrantLock and ReadWriteLock

Conclusion

Locks in Java provide fine-grained control over thread synchronization. They are more powerful than synchronized and are essential for building high-performance, thread-safe applications.

If your application has complex concurrency requirements, Locks are the right choice.