java.util.concurrent: ReentrantLock, ReadWriteLock, and Condition0%

Thread Pools with ExecutorService, Callable<T>, and Future<T>

java.util.concurrent: ReentrantLock, ReadWriteLock, and Condition

Advanced16 min read•Updated: 2025-01-15

🔐 java.util.concurrent: ReentrantLock, ReadWriteLock, and Condition

Introduction

While intrinsic synchronized locks are easy to use, they are rigid: a thread cannot interrupt lock acquisition, cannot attempt a timed lock acquisition, and cannot separate read operations from write operations.

Java 5 introduced java.util.concurrent.locks providing explicit, powerful lock implementations.

🔑 1. `ReentrantLock`

Provides explicit lock() and unlock() controls. Crucial Rule: Always release explicit locks inside a finally block!

1import java.util.concurrent.locks.ReentrantLock;
2 
3public class InventoryService {
4    private final ReentrantLock lock = new ReentrantLock();
5 
6    public void processItem(int itemId) {
7        lock.lock(); // Acquire lock explicitly
8        try {
9            // Critical section
10            updateStock(itemId);
11        } finally {
12            lock.unlock(); // Always release in finally to prevent permanent deadlocks!
13        }
14    }
15}

Non-Blocking Lock Acquisition with `tryLock()`:

1if (lock.tryLock(2, TimeUnit.SECONDS)) {
2    try {
3        // Proceed with critical section
4    } finally {
5        lock.unlock();
6    }
7} else {
8    // Fallback logic when lock is busy; no thread hanging!
9}

📖 2. `ReentrantReadWriteLock` (High-Read Performance)

In applications where reads occur 99% of the time and writes occur 1% of the time, standard mutual exclusion kills performance. A ReadWriteLock allows:

Multiple readers concurrently (shared lock)
Only one writer exclusively (exclusive lock)

1import java.util.concurrent.locks.ReentrantReadWriteLock;
2 
3public class CachedPrices {
  private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
  private double goldPrice = 6500.0;
6 
  // Concurrent reads
  public double getPrice() {
      rwLock.readLock().lock();
      try {
          return goldPrice;
      } finally {
          rwLock.readLock().unlock();
      }
  }
16 
  // Exclusive write
  public void updatePrice(double newPrice) {
      rwLock.writeLock().lock();
      try {
          this.goldPrice = newPrice;
      } finally {
          rwLock.writeLock().unlock();
      }
  }
26}

Next Lesson

Thread Pools with ExecutorService, Callable<T>, and Future<T>

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Inter-Thread Communication: wait(), notify(), and notifyAll()	Thread Pools with ExecutorService, Callable<T>, and Future<T>

Practice Quiz

Test your understanding of this lesson with 1 questions. Each question has one correct answer.

Previous Next

PreviousPrevNext

MSK Institute • Shikohabad

Loading Page Content...

Preparing courses, live labs, and learning resources.सामग्री लोड हो रही है, कृपया प्रतीक्षा करें...

Connecting serverPlease wait...

💻 Practical Labs🚀 Free Demo📜 Verified Certificates

Thread Pools with ExecutorService, Callable<T>, and Future<T>

java.util.concurrent: ReentrantLock, ReadWriteLock, and Condition

Advanced16 min read•Updated: 2025-01-15

Study Materials

🔐 java.util.concurrent: ReentrantLock, ReadWriteLock, and Condition

Introduction

Java 5 introduced java.util.concurrent.locks providing explicit, powerful lock implementations.

🔑 1. `ReentrantLock`

Provides explicit lock() and unlock() controls. Crucial Rule: Always release explicit locks inside a finally block!

1import java.util.concurrent.locks.ReentrantLock;
2 
3public class InventoryService {
4    private final ReentrantLock lock = new ReentrantLock();
5 
6    public void processItem(int itemId) {
7        lock.lock(); // Acquire lock explicitly
8        try {
9            // Critical section
10            updateStock(itemId);
11        } finally {
12            lock.unlock(); // Always release in finally to prevent permanent deadlocks!
13        }
14    }
15}

Non-Blocking Lock Acquisition with `tryLock()`:

1if (lock.tryLock(2, TimeUnit.SECONDS)) {
2    try {
3        // Proceed with critical section
4    } finally {
5        lock.unlock();
6    }
7} else {
8    // Fallback logic when lock is busy; no thread hanging!
9}

📖 2. `ReentrantReadWriteLock` (High-Read Performance)

In applications where reads occur 99% of the time and writes occur 1% of the time, standard mutual exclusion kills performance. A ReadWriteLock allows:

Multiple readers concurrently (shared lock)
Only one writer exclusively (exclusive lock)

1import java.util.concurrent.locks.ReentrantReadWriteLock;
2 
3public class CachedPrices {
  private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
  private double goldPrice = 6500.0;
6 
  // Concurrent reads
  public double getPrice() {
      rwLock.readLock().lock();
      try {
          return goldPrice;
      } finally {
          rwLock.readLock().unlock();
      }
  }
16 
  // Exclusive write
  public void updatePrice(double newPrice) {
      rwLock.writeLock().lock();
      try {
          this.goldPrice = newPrice;
      } finally {
          rwLock.writeLock().unlock();
      }
  }
26}

Next Lesson

Thread Pools with ExecutorService, Callable<T>, and Future<T>

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Inter-Thread Communication: wait(), notify(), and notifyAll()	Thread Pools with ExecutorService, Callable<T>, and Future<T>

Practice Quiz

Test your understanding of this lesson with 1 questions. Each question has one correct answer.

Previous Next

🔐 java.util.concurrent: ReentrantLock, ReadWriteLock, and Condition

Introduction

🔑 1. ReentrantLock

Non-Blocking Lock Acquisition with tryLock():

📖 2. ReentrantReadWriteLock (High-Read Performance)

Thread Pools with ExecutorService, Callable<T>, and Future<T>

Related Lessons

Practice Quiz

Loading Page Content...

🔐 java.util.concurrent: ReentrantLock, ReadWriteLock, and Condition

Introduction

🔑 1. ReentrantLock

Non-Blocking Lock Acquisition with tryLock():

📖 2. ReentrantReadWriteLock (High-Read Performance)

Thread Pools with ExecutorService, Callable<T>, and Future<T>

Related Lessons

Practice Quiz

🔑 1. `ReentrantLock`

Non-Blocking Lock Acquisition with `tryLock()`:

📖 2. `ReentrantReadWriteLock` (High-Read Performance)

🔑 1. `ReentrantLock`

Non-Blocking Lock Acquisition with `tryLock()`:

📖 2. `ReentrantReadWriteLock` (High-Read Performance)