Java Multithreading Locks - Simplified Guide

🔐 Why Locks?

Locks are used to ensure only one thread accesses shared data at a time.

🧠 Key Concepts

Concept	Description
Critical Section	Shared code that needs exclusive access
Race Condition	Bug from unsynchronized access
Deadlock	Two threads waiting on each other’s locks
Mutual Exclusion	Ensures one thread executes a section at a time

---

Comparison Table

Feature	synchronized	ReentrantLock	ReadWriteLock	volatile
Thread Safety	✅	✅	✅	❌ (visibility only)
Read/Write Split	❌	❌	✅	❌
Fairness	❌	✅ (optional)	✅	❌
Manual Lock Control	❌	✅	✅	❌
Performance (Reads)	⚠️	⚠️	✅	✅

---

🔁 synchronized Keyword

🔒 Basic Use

public synchronized void increment() {
    count++;
}

🔒 Block Scope

synchronized(this) {
    count++;
}

🔒 Static Method

public static synchronized void increment() {
    count++;
}

⚠ Limitations

• No timeout
• No lock status check
• No fairness control

✅ Example

public class SyncExample {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }

    public static void main(String[] args) throws InterruptedException {
        SyncExample counter = new SyncExample();
        Thread t1 = new Thread(() -> { for (int i = 0; i < 1000; i++) counter.increment(); });
        Thread t2 = new Thread(() -> { for (int i = 0; i < 1000; i++) counter.increment(); });

        t1.start(); t2.start();
        t1.join(); t2.join();

        System.out.println("Count: " + counter.getCount());
    }
}

🔄 Output

Count: 2000

🧠 Insight

synchronized ensures only one thread at a time enters the critical section. Good for simple synchronization but lacks flexibility.

---

🔧 ReentrantLock

✨ Features

• Manual control (lock(), unlock())
• Fairness support
• Timeout & interruptible locks

✅ Example

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

⏱ With Timeout

if (lock.tryLock(1, TimeUnit.SECONDS)) {
    try {
        // critical section
    } finally {
        lock.unlock();
    }
}

✅ Example

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();

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

    public int getCount() { return count; }

    public static void main(String[] args) throws InterruptedException {
        ReentrantLockExample example = new ReentrantLockExample();
        Thread t1 = new Thread(() -> { for (int i = 0; i < 1000; i++) example.increment(); });
        Thread t2 = new Thread(() -> { for (int i = 0; i < 1000; i++) example.increment(); });

        t1.start(); t2.start();
        t1.join(); t2.join();

        System.out.println("Count: " + example.getCount());
    }
}

🔄 Output

Count: 2000

🧠 Insight

Use ReentrantLock for advanced features: tryLock, fairness, and interruptible locks.

---

📖 ReadWriteLock

🔍 Use Case

Multiple readers OR one writer – good for read-heavy scenarios.

✅ Example

ReadWriteLock rwLock = new ReentrantReadWriteLock();
rwLock.readLock().lock();   // for reading
rwLock.writeLock().lock();  // for writing

✅ Example

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteExample {
    private int data = 0;
    private final ReentrantReadWriteLock rw = new ReentrantReadWriteLock();

    public void write() {
        rw.writeLock().lock();
        try {
            data++;
            System.out.println("Written: " + data);
        } finally {
            rw.writeLock().unlock();
        }
    }

    public void read() {
        rw.readLock().lock();
        try {
            System.out.println("Read: " + data);
        } finally {
            rw.readLock().unlock();
        }
    }

    public static void main(String[] args) {
        ReadWriteExample obj = new ReadWriteExample();
        obj.write();
        obj.read();
    }
}

🔄 Output

Written: 1
Read: 1

🧠 Insight

Improves performance in read-heavy environments by allowing multiple concurrent reads.

---

🌀 StampedLock

🚀 Feature

Allows optimistic read – great for fast non-blocking reads.

✅ Optimistic Read

long stamp = lock.tryOptimisticRead();
int result = data;
if (!lock.validate(stamp)) {
    stamp = lock.readLock();
    result = data;
    lock.unlockRead(stamp);
}

✅ Example

import java.util.concurrent.locks.StampedLock;

public class StampedLockExample {
    private int data = 0;
    private final StampedLock lock = new StampedLock();

    public void write() {
        long stamp = lock.writeLock();
        try {
            data++;
            System.out.println("Write: " + data);
        } finally {
            lock.unlockWrite(stamp);
        }
    }

    public void optimisticRead() {
        long stamp = lock.tryOptimisticRead();
        int current = data;
        if (!lock.validate(stamp)) {
            stamp = lock.readLock();
            try { current = data; }
            finally { lock.unlockRead(stamp); }
        }
        System.out.println("Read: " + current);
    }

    public static void main(String[] args) {
        StampedLockExample ex = new StampedLockExample();
        ex.write();
        ex.optimisticRead();
    }
}

🔄 Output

Write: 1
Read: 1

🧠 Insight

Great for performance when contention is low, using optimistic reading to avoid locks.

---

🧵 Condition Variables

⏸ Wait & Notify

Replaces wait/notify with more flexible await/signal.

✅ Example

lock.lock();
try {
    while (queue.isEmpty()) {
        notEmpty.await();
    }
    // process
    notFull.signal();
} finally {
    lock.unlock();
}

---

🔢 Semaphore

🎛 Controls Access

Allows N threads to access a resource simultaneously.

✅ Example

Semaphore sem = new Semaphore(3);
sem.acquire();
// access resource
sem.release();

✅ Example

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private static final Semaphore sem = new Semaphore(2);

    public static void main(String[] args) {
        Runnable task = () -> {
            try {
                System.out.println(Thread.currentThread().getName() + " waiting...");
                sem.acquire();
                System.out.println(Thread.currentThread().getName() + " acquired.");
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + " releasing...");
                sem.release();
            } catch (InterruptedException e) { e.printStackTrace(); }
        };

        for (int i = 0; i < 4; i++) new Thread(task).start();
    }
}

🔄 Output

Thread-0 waiting...
Thread-1 waiting...
Thread-0 acquired.
Thread-1 acquired.
Thread-2 waiting...
Thread-3 waiting...
Thread-0 releasing...
Thread-1 releasing...
Thread-2 acquired.
Thread-3 acquired.

🧠 Insight

Perfect for limiting concurrent access, such as in connection pools or rate limiters.

---

⚙ Lock-Free Programming

🔁 Atomic Operations

✅ Example

AtomicInteger count = new AtomicInteger(0);
count.incrementAndGet();

✅ Compare-and-Set

AtomicReference<String> value = new AtomicReference<>("a");
value.compareAndSet("a", "b");

✅ Example

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {
    private final AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }

    public static void main(String[] args) {
        AtomicExample obj = new AtomicExample();
        obj.increment();
        System.out.println("Count: " + obj.get());
    }
}

🔄 Output

Count: 1

🧠 Best Practices

1. Always use try-finally with manual locks
2. Keep critical sections small
3. Avoid nested locks
4. Use atomic types for simple counters
5. Prefer lock-free when possible

📊 Summary Table

Lock Type	Use Case	Performance	Complexity
synchronized	Simple lock	✅ Good	🟢 Easy
ReentrantLock	Fine control	✅ Great under load	🟡 Medium
ReadWriteLock	Read-heavy	✅ Excellent	🟡 Medium
StampedLock	High concurrency	✅ Best for reads	🔴 High
Semaphore	Limit access	✅ Scalable	🟡 Medium
Atomic Variables	Lock-free operations	✅ Fastest	🟢 Easy

---