深入理解高并发编程 - AQS 中的 ReentrantLock、ReentrantReadWriteLock、 StampedLock 与 Condition

我会带着你远行 2023-10-15 09:57 154阅读 0赞

## ReentrantLock ##

ReentrantLock（可重入锁）是Java编程语言中的一种锁实现，它提供了一种基于显示锁（explicit lock）的机制，用于控制对共享资源的访问。与内置的synchronized关键字相比，ReentrantLock提供了更多的灵活性和功能，允许更细粒度的锁控制。

以下是关于ReentrantLock的一些重要概念和特点：

可重入性： ReentrantLock允许同一个线程多次获取同一个锁而不会导致死锁，这种特性被称为可重入性（Reentrancy）或递归性。在同一个线程内部，每次获取锁时，锁的计数器会递增，然后在解锁时递减，只有当计数器降至零时锁才被完全释放。
    
    锁的公平性： ReentrantLock可以选择是公平锁还是非公平锁。公平锁会按照获取锁的顺序分配锁，而非公平锁则不保证按照顺序分配。
    
    条件变量： ReentrantLock提供了条件变量（Condition）的功能，用于在某些条件满足时等待或唤醒线程。可以通过newCondition()方法创建条件变量，然后使用await()等待和signal()唤醒。
    
    可中断性： 通过lockInterruptibly()方法，可以在等待锁时响应中断，这意味着如果一个线程正在等待获取锁时被中断，它会立即退出等待状态并抛出InterruptedException。
    
    超时获取锁： tryLock(long time, TimeUnit unit)方法允许在指定的时间内尝试获取锁，如果在超时时间内未获取到锁，方法会返回相应的结果。
    
    手动解锁： 与synchronized不同，ReentrantLock需要显式地调用unlock()方法来释放锁，确保锁的释放操作在适当的地方进行。
    
    性能优势： 在某些情况下，ReentrantLock相对于synchronized可能具有更好的性能，尤其是在高竞争的多线程环境中。

使用ReentrantLock需要注意以下几点：

必须确保在获取锁后适时释放锁，否则可能会导致死锁或其他并发问题。
    在使用条件变量时，需要仔细处理等待和唤醒的逻辑，以避免线程无法正确唤醒或等待超时等问题。
    对于简单的同步需求，synchronized可能更加简洁和方便，因为它由Java语言提供的内置特性。

总的来说，ReentrantLock是一种强大的锁机制，适用于需要更多灵活性和功能的并发场景。但在选择锁机制时，需要根据具体情况综合考虑性能、复杂性和可读性。

## ReentrantReadWriteLock ##

ReentrantReadWriteLock是Java编程语言中的另一种锁实现，它提供了一种更为灵活的读写锁机制，用于控制对共享资源的并发访问。与ReentrantLock相比，ReentrantReadWriteLock允许多个线程同时读取共享资源，但在写入时会排他地独占资源。

以下是关于ReentrantReadWriteLock的一些关键概念和特点：

读锁（Shared Lock）： 多个线程可以同时获取读锁，从而允许并发读取共享资源。当没有线程持有写锁时，可以有多个线程持有读锁。这种机制适用于读多写少的场景，可以提高并发性能。
    
    写锁（Exclusive Lock）： 写锁是排他的，只有一个线程能够持有写锁，且其他线程无法同时持有读锁或写锁。当某个线程持有写锁时，其他线程无法获取任何锁。
    
    可重入性： 与ReentrantLock一样，ReentrantReadWriteLock也支持可重入性，即同一个线程可以多次获取相同类型的锁。
    
    锁降级和升级： ReentrantReadWriteLock允许锁的降级，即从写锁降级为读锁，以及锁的升级，即从读锁升级为写锁。这可以在一些场景中减少锁竞争的时间。
    
    性能提升： 在适当的场景下，使用读写锁可以显著提升并发性能。读锁的并发访问可以有效地提高资源利用率。

与使用ReentrantLock类似，使用ReentrantReadWriteLock也需要注意以下几点：

写锁的持有时间应尽量短，以减少对读锁的阻塞时间，从而避免写饥饿。
    需要权衡读写频率和性能优势。如果读操作远远多于写操作，那么使用读写锁可能是个不错的选择。
    写锁的排他性可能导致写线程等待时间过长，特别是在有大量读线程的情况下，需要注意性能瓶颈。

总之，ReentrantReadWriteLock适用于那些读取操作频繁、写入操作较少且对并发性能要求较高的场景。然而，在某些情况下，过多地使用读写锁可能会导致复杂性增加，因此需要谨慎使用并根据具体情况做出权衡。

## StampedLock ##

StampedLock 是 Java 8 引入的一种新型锁，它是基于乐观读取、悲观读取和写锁的一种机制，旨在提供更高的并发性能。StampedLock的设计目标是在读多写少的情况下，提供更好的性能。

以下是关于 StampedLock 的一些重要概念和特点：

乐观读锁（Optimistic Read）： 乐观读锁允许多个线程同时读取数据，不会阻塞其他线程的读操作，即使有写操作正在进行。在乐观读锁中，线程首先尝试读取数据，但不会阻塞其他线程的写操作。然后，线程在读取数据后获取一个“标记”（stamp）值，如果在读取数据后没有发生写操作，该标记仍然有效。
    
    验证标记（Validate Stamp）： 在乐观读取后，线程需要验证获取的标记是否仍然有效。这是因为其他线程可能已经进行了写操作，使得当前线程的读操作无效。通过验证标记，可以判断是否需要进行后续的真实读操作或悲观读锁。
    
    悲观读锁（Read Lock）： 悲观读锁与传统的读锁类似，当线程需要进行较长时间的读操作时，可以获取悲观读锁。悲观读锁会阻塞其他线程的写操作和乐观读锁，确保数据的一致性。
    
    写锁（Write Lock）： 写锁是排他的，它会阻塞其他线程的读操作和写操作。与其他锁一样，写锁用于对共享资源进行修改操作，确保数据的完整性。
    
    尝试转换锁： StampedLock 提供了尝试将乐观读锁转换为悲观读锁或写锁的方法，以及将悲观读锁转换为写锁的方法。这允许线程在某些条件下转换锁，避免了多次获取和释放锁的开销。
    
    适用性注意事项： StampedLock 适用于读多写少的场景。在写操作频率较高的情况下，可能会出现饥饿问题。

虽然 StampedLock 提供了更灵活的锁机制，但使用它需要特别注意以下事项：

StampedLock 的设计适用于特定场景，不是适合所有情况的通用解决方案。
    乐观读锁需要进行标记的验证，而这个验证本身可能会消耗一定的性能。
    当悲观读锁和写锁的竞争激烈时，可能导致读线程的性能下降。

总之，StampedLock 可以在适当的场景中提供更高的并发性能，但需要根据实际需求进行合适的选择，避免不必要的复杂性。

## Condition ##

Condition（条件）是一种用于线程间协作的机制，通常与锁一起使用，允许线程在某些条件满足时等待或被唤醒。Condition 提供了比传统的 wait() 和 notify() 更灵活的等待和通知机制，允许线程在特定条件下等待，以及在满足条件时通知其他线程。

Condition 接口提供了以下主要方法：

await()： 当一个线程调用 await() 方法时，它会释放锁并进入等待状态，直到其他线程调用相应的 signal() 或 signalAll() 方法唤醒它。
    
    awaitUninterruptibly()： 与 await() 类似，但是 awaitUninterruptibly() 方法不会响应中断，即使线程被中断，也不会提前唤醒。
    
    awaitNanos(long nanosTimeout) 和 await(long time, TimeUnit unit)： 这两个方法允许线程在一定的时间内等待，超过时间后自动唤醒。
    
    awaitUntil(Date deadline)： 允许线程在指定的时间点之前等待，超过时间后自动唤醒。
    
    signal() 和 signalAll()： 用于唤醒等待在该条件上的一个或多个线程。signal() 方法只会唤醒一个线程，而 signalAll() 方法会唤醒所有等待的线程。

Condition 通常与锁对象一起使用，可以通过 Lock 接口的 newCondition() 方法创建条件对象。例如，在 ReentrantLock 中，你可以使用以下方式来获取一个条件对象：

ReentrantLock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

经典的使用场景之一是生产者-消费者问题，其中生产者在某些条件（如缓冲区满）下等待，而消费者在其他条件（如缓冲区空）下等待。

需要注意的是，Condition 必须与相应的锁一起使用。等待方法必须在获得锁的情况下调用，以确保正确的同步。await() 方法会释放锁，并在等待时允许其他线程访问共享资源，因此在使用时需要注意资源的同步。

总的来说，Condition 提供了更灵活的线程间协作机制，适用于那些需要在特定条件下等待或唤醒的并发场景。

## 生产者-消费者问题的多线程协作 ##

import java.util.LinkedList;
    import java.util.Queue;
    import java.util.concurrent.Semaphore;
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class ThreadSyncExample {
        public static void main(String[] args) {
            final int numProducers = 2;
            final int numConsumers = 3;
            final int maxQueueSize = 5;
            final Queue<Integer> taskQueue = new LinkedList<>();
            final Lock lock = new ReentrantLock();
            final Condition notFull = lock.newCondition();
            final Condition notEmpty = lock.newCondition();
            final Semaphore semaphore = new Semaphore(maxQueueSize);
    
            // 创建并启动生产者线程
            for (int i = 0; i < numProducers; i++) {
                Thread producer = new Thread(() -> {
                    while (true) {
                        try {
                            semaphore.acquire(); // 申请一个许可证，表示可以添加任务
                            int task = produceTask(); // 生产任务
                            lock.lock(); // 获取锁
                            try {
                                while (taskQueue.size() >= maxQueueSize) {
                                    notFull.await(); // 等待队列不满
                                }
                                taskQueue.add(task); // 添加任务到队列
                                System.out.println("Produced: " + task);
                                notEmpty.signalAll(); // 唤醒等待的消费者线程
                            } finally {
                                lock.unlock(); // 释放锁
                            }
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                            break;
                        }
                    }
                });
                producer.start();
            }
    
            // 创建并启动消费者线程
            for (int i = 0; i < numConsumers; i++) {
                Thread consumer = new Thread(() -> {
                    while (true) {
                        lock.lock(); // 获取锁
                        try {
                            while (taskQueue.isEmpty()) {
                                notEmpty.await(); // 等待队列不为空
                            }
                            int task = taskQueue.poll(); // 取出任务
                            System.out.println("Consumed: " + task);
                            notFull.signalAll(); // 唤醒等待的生产者线程
                            semaphore.release(); // 释放许可证
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                            break;
                        } finally {
                            lock.unlock(); // 释放锁
                        }
                    }
                });
                consumer.start();
            }
        }
    
        private static int produceTask() {
            return (int) (Math.random() * 100);
        }
    }