JUC并发编程_Lock锁

1、Lock锁介绍

Java中的 Lock 锁是 java.util.concurrent.locks 包下的一个接口，它提供了比 synchronized 关键字更灵活的锁定机制。

2、主要方法

• lock()：获取锁。如果锁不可用，则当前线程将被禁用，直到锁变为可用。
• tryLock()：尝试获取锁，如果锁可用，则获取锁并立即返回true；如果锁不可用，则立即返回false，并且当前线程不会被禁用。
• tryLock(long time, TimeUnit unit)：尝试获取锁，如果锁在给定的等待时间内可用，并且当前线程未被中断，则获取锁。
• lockInterruptibly()：用于以可中断的方式获取锁。这个方法与 lock() 方法的主要区别在于，当线程尝试获取锁而锁已被其他线程持有时，lock() 方法会使线程在锁上无限期地等待，直到锁变为可用；而 lockInterruptibly() 方法允许等待锁的线程在等待过程中响应中断
• unlock()：释放锁
• newCondition()：返回绑定到此 Lock 实例的新 Condition 实例。Condition 提供了与Object监视器方法（如wait、notify和notifyAll）类似的功能，但与Lock实例相关联。

3、与 synchronized 的区别

• 灵活性：Lock 锁提供了比 synchronized 更灵活的锁定操作。例如，tryLock 方法允许在不能立即获取锁时不会使线程进入阻塞状态，而是返回一个布尔值。
• 可中断性：Lock 锁支持获取锁时的中断响应，而 synchronized 不支持。这意味着如果某个线程在等待锁的过程中被中断，它可以立即响应中断，而不是无限期地等待
• 超时尝试：Lock 锁允许尝试获取锁时设置超时时间，如果在这个时间内锁没有被获取到，则线程可以放弃等待，去做其他事情
• 条件变量：Lock 锁提供了 Condition 接口，支持多个条件变量，而 synchronized 关键字则只有一个条件变量（即对象监视器）
• 锁的获取和释放：synchronized 锁的获得和释放都是自动的，Lock 锁需要手动获取和释放。
• 锁的公平性：synchronized 锁是非公平锁，Lock 锁默认是非公平锁的，但可以通过构造函数传参改变为公平锁。
• 精准唤醒：synchronized 的唤醒机制是基于 wait/notify 或 notifyAll 方法的，其中 notify 方法只能随机唤醒等待队列中的一个线程，无法做到精准唤醒。Lock 锁可以通过操作不同 Condition 实例的 signal() 方法实现精准唤醒。

4、Condition 使用示例

创建一个简单的生产者-消费者场景，其中使用 ReentrantLock（Lock接口的一个实现）和 Condition 来控制对共享资源的访问

import java.util.LinkedList;  
import java.util.Queue;  
import java.util.concurrent.locks.Condition;  
import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReentrantLock;  
  
public class ProducerConsumerExample {  
    private final Queue<Integer> queue = new LinkedList<>();  
    private final int capacity = 10;  
    private final Lock lock = new ReentrantLock();  
    private final Condition notFull = lock.newCondition();  
    private final Condition notEmpty = lock.newCondition();  
  
    public void produce(int value) throws InterruptedException {  
        lock.lock();  
        try {  
            while (queue.size() == capacity) {  
                // 当队列满时，生产者等待  
                notFull.await();  
            }  
            queue.add(value);  
            System.out.println("Produced: " + value);  
            // 通知消费者队列中有新元素  
            notEmpty.signal();  
        } finally {  
            lock.unlock();  
        }  
    }  
  
    public void consume() throws InterruptedException {  
        lock.lock();  
        try {  
            while (queue.isEmpty()) {  
                // 当队列空时，消费者等待  
                notEmpty.await();  
            }  
            int value = queue.poll();  
            System.out.println("Consumed: " + value);  
            // 通知生产者队列中有空间  
            notFull.signal();  
        } finally {  
            lock.unlock();  
        }  
    }  
  
    public static void main(String[] args) {  
        ProducerConsumerExample example = new ProducerConsumerExample();  
  
        // 创建生产者和消费者线程  
        Thread producer = new Thread(() -> {  
            for (int i = 0; i < 20; i++) {  
                try {  
                    example.produce(i);  
                    Thread.sleep(100); // 模拟耗时操作  
                } catch (InterruptedException e) {  
                    Thread.currentThread().interrupt();  
                }  
            }  
        });  
  
        Thread consumer = new Thread(() -> {  
            for (int i = 0; i < 20; i++) {  
                try {  
                    example.consume();  
                    Thread.sleep(150); // 模拟耗时操作  
                } catch (InterruptedException e) {  
                    Thread.currentThread().interrupt();  
                }  
            }  
        });  
  
        // 启动线程  
        producer.start();  
        consumer.start();  
    }  
}

• await() 方法

await() 方法是 Condition 接口中的一个方法，它会使当前线程进入等待状态（即阻塞），直到其他线程调用该Condition 的 signal() 或 signalAll() 方法，或者当前线程被中断，或者等待过程中发生了 InterruptedException 异常。

在调用 await() 方法之前，当前线程必须已经获得了与 Condition 相关联的锁。调用 await() 方法后，当前线程会释放这个锁，并进入等待状态。当线程从 await() 方法返回时，它必须重新获取这个锁才能继续执行。

在 ProducerConsumerExample 的 produce 方法中，当队列满时，生产者线程会调用 notFull.await() 等待，直到有消费者线程消费了队列中的元素并调用了 notFull.signal() 或 notFull.signalAll() 方法。

在 consume 方法中，当队列空时，消费者线程会调用 notEmpty.await() 等待，直到有生产者线程生产了新的元素并调用了 notEmpty.signal() 或 notEmpty.signalAll() 方法。

• signal() 方法

signal() 方法是 Condition 接口中的一个方法，它用于唤醒等待在该 Condition 上的单个线程（如果有的话）。在调用 signal() 方法之前，当前线程必须已经获得了与 Condition 相关联的锁。

在 ProducerConsumerExample 的 produce 方法中，当生产者线程成功地将一个元素添加到队列中后，它会调用 notEmpty.signal() 来唤醒可能正在等待的消费者线程（如果有的话），以便消费者线程可以消费这个新元素。

在 consume 方法中，当消费者线程成功地从队列中取出一个元素后，它会调用 notFull.signal() 来唤醒可能正在等待的生产者线程（如果有的话），以便生产者线程可以继续生产新的元素。

需要注意的是，signal() 方法只会唤醒等待队列中的一个线程，而 signalAll() 方法会唤醒等待队列中的所有线程。在这个例子中，我们使用了 signal() 方法，因为生产者-消费者问题通常只需要唤醒一个等待的线程（生产者唤醒消费者，或消费者唤醒生产者）。然而，在某些情况下，使用 signalAll() 可能更合适，特别是当你不确定应该唤醒哪个线程时。但是，使用 signalAll() 可能会导致不必要的线程唤醒和竞争，从而影响性能。