Java 入门指南：Java 并发编程 —— Condition 灵活管理线程间的同步

Condition

Condition 是 Java 并发编程中的一种高级同步工具，它可以协助线程之间进行等待和通信。提供了一种比传统的 wait() 和 notify() 更加灵活的方式来管理线程间的同步。Condition 接口通常与 Lock 接口一起使用，允许更细粒度的控制线程的等待和唤醒。

每个 Condition 对象都与一个 Lock 对象相关联，它可以在等待之前获取到锁，并在等待期间自动释放锁。一旦其他线程对相关的数据做出更改并且满足某个特定条件，Condition 就可以被用来通知正在等待的线程，并进行唤醒等待的操作。

接口方法

Condition 接口提供了如下方法：

• await()：线程等待直到其他线程调用相同 Condition 对象的 signal/signalAll 方法，并且当前线程被唤醒；其他线程调用 interrupt 方法中断当前线程。类似于 Object.wait()。

• await(long time, TimeUnit unit)：线程等待指定的时间，或被通知，或被中断。类似于 Object.wait(long timeout)，但提供了更灵活的时间单位。

• awaitUninterruptibly()：线程等待直到被通知，即使在等待时被中断也不会返回，不响应中断。没有与之对应的 Object 方法。

• awaitNanos(long nanosTimeout)：线程等待指定的纳秒时间，或被通知，或被中断，返回值小于等于0，认定为超时。没有与之对应的 Object 方法。

• awaitUntil(Date deadline)：线程等待直到指定的截止日期，或被通知，或被中断。如果没到指定时间被通知，则返回 true，否则返回 false。没有与之对应的 Object 方法。

• signal()：唤醒一个等待在 Condition 上的线程，被唤醒的线程在方法返回前必须获得与 Condition 对象关联的锁。类似于 Object.notify()。

• signalAll()：唤醒所有等待在 Condition 上的线程，能够从 await()等方法返回的线程必须先获得与 Condition 对象关联的锁。类似于 Object.notifyAll()。

await()

方法逻辑：

1. 如果当前线程被中断，抛出 InterruptedException。

2. 通过 getState() 保存锁状态。

3. 以保存的锁状态作为参数调用 release()，如果失败则抛出IllegalMonitorStateException。

4. 阻塞直到被通知或线程中断。

5. 通过以保存状态作为参数调用 acquire() 的带参方法来重新获取锁。

6. 如果在第4步阻塞时中断，则抛出 InterruptedException。

调用 condition.await 方法的线程必须是已经获得了 lock 的线程，也就是当前线程是同步队列中的头节点。

当前线程调用condition.await() 方法后，会释放 lock 然后加入到等待队列，直到被 signal/signalAll 方法唤醒。

线程如何被添加到等待队列

在 await() 中 调用了 addConditionWaiter 方法会将当前线程添加到等待队列中。

将不处于等待状态的节点从等待队列中移除，通过尾插入的方式将当前线程封装的 Node 插入到等待队列中，同时可以看出，Condtion 的等待队列是一个不带头节点的链式队列。

释放锁的过程

将当前节点插入到等待对列之后，会使当前线程释放 lock，由 fullyRelease 方法实现

首先获取锁的状态，调用 AQS 的模板方法 release 释放 AQS 的同步状态，并且唤醒在同步队列中头节点的后继节点引用的线程，如果释放成功则正常返回，若失败，抛出 IllegalMonitorStateException，并将节点状态设置为 CANCELLED

退出 await()

退出 await 方法的前提条件是当前线程被中断或者调用 condition.signal() 或者 condition.signalAll() 使当前节点移动到同步队列后。

当退出 while 循环后会调用 acquireQueued(node, savedState)，该方法的作用是在自旋过程中线程不断尝试获取同步状态，直到成功（线程获取到 lock）。这样也说明了退出 await 方法必须是已经获得了 condition 引用（关联）的 lock。

signal()

调用 condition 的 signal() 或者 signalAll() 方法可以将等待队列中等待时间最长的节点移动到同步队列中，使得该节点能够有机会获得 lock。

signal() 方法源码

doSignal() 方法源码

调用 condition.signal 方法的前提条件是当前线程已经获取了 lock，若未获得 lock，会直接抛出 IllegalMonitorStateException

等待队列是先进先出（FIFO）的，所以等待队列的头节点必然会是等待时间最长的节点，也就是每次调用 condition 的 signal 方法都会将头节点的状态设置为 CONDITION，并移动到同步队列中。

signalAll()

signalAll 与 signal 方法的区别体现在 doSignalAll 方法上，该方法会将等待队列中的每一个节点都移入到同步队列中，即“通知”当前调用 condition.await() 方法的每一个线程。

await() 与 signal()

await、signal 和 signalAll 方法就像一个开关，控制着线程 A（等待方）和线程 B（通知方）

• 线程 awaitThread 先通过 lock.lock() 方法获取锁，成功后调用 condition.await 方法进入等待队列

• 另一个线程 signalThread 通过 lock.lock() 方法获取锁成功后调用了 condition.signal 或者 signalAll 方法，使得线程 awaitThread 能够有机会移入到同步队列中.

• 当其他线程释放 lock 后使得线程 awaitThread 能够有机会获取 lock，从而使得线程 awaitThread 能够从 await 方法中退出并执行后续操作。

• 如果 awaitThread 获取 lock 失败会直接进入到同步队列。

创建 Condition 对象

可以通过 lock.newCondition() 来创建一个 Condition 对象，这个方法实际上会 new 一个 ConditionObject 的对象，ConditionObject 是 [[AQS、AQLS、AOS]] 的一个内部类

AQS 内部维护了一个 FIFO 的双端队列，Condition 内部也使用了同样的方式，内部维护了一个先进先出（FIFO）的单向队列，称为等待队列。

用 await 方法的线程都会加入到等待队列中，并且线程状态均为等待状态。firstWaiter 指向首节点，lastWaiter 指向尾节点

Node 中的 nextWaiter 指向队列中的下一个节点。并且进入到等待队列的 Node 节点状态都会被设置为 CONDITION

如果该线程能够从 await() 方法返回的话，一定是该线程获取了与 Condition 相关联的锁。

可以多次调用 newCondition() 方法创建多个 Condition 对象，也就是一个 lock 可以持有多个等待队列。

使用多个 Condition 对象的主要优点是为锁提供了更细粒度的控制，可以实现更复杂的同步场景。

Object.monitor 和 Condition

每个对象都可以用 Object 的 wait() 、notify() 方法来实现等待/通知机制。而 Condition 接口也提供了类似 Object 的方法 await() signal()，可以配合Lock 来实现等待/通知模式。****

相似之处

1. 线程等待：Condition 的 await() 方法和 Object 的 wait() 方法都可以使当前线程进入等待状态，直到被其他线程唤醒。

2. 线程唤醒：

   • Condition 的 signal() 方法和 Object 的 notify() 方法都可以唤醒一个等待的线程。
   • Condition 的 signalAll() 方法类似于 Object 的 notifyAll() 方法，可以唤醒所有等待的线程。

不同之处

1. 锁的显式管理：

   • Condition 必须与 Lock 结合使用，这意味着开发者需要显式地管理锁的获取和释放。这使得代码结构更加清晰，可以避免一些常见的锁使用错误。
   • Object 的 wait 和 notify 方法则隐含地使用了对象的内置锁（即 synchronized 语句块或方法所持有的锁）。

2. 多个条件变量：Condition 允许在同一把锁上创建多个条件变量，这意味着可以在一个锁对象上实现多个不同的等待条件，而 Object 的 wait/notify 方法只能在单个对象上实现单一的等待条件。

3. 更细粒度的控制：

   • Condition 提供了更多控制选项，例如 awaitNanos、awaitUntil 等方法，可以设置等待的超时时间，这使得线程可以在指定时间内等待，而不是无限期地等待。

   • Object 的 wait 方法虽然也有超时参数，但在使用上不如 Condition 灵活。

4. 异常处理：

   • Condition 的 await 方法在等待过程中可能会被中断，从而抛出 InterruptedException。此时，开发人员可以选择是否恢复中断状态。

   • Object 的 wait 方法同样会在线程被中断时抛出 InterruptedException，但恢复中断状态需要手动设置。

Condition 实现生产者消费者模式

下面是一个使用 Condition 实现的生产者消费者模式的例子，该模式常用于线程间的同步问题。

仓库类

首先，我们定义一个仓库类，它包含一个生产者使用的 put 方法和消费者使用的 take 方法。

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

public class Warehouse {
    private final int maxSize;
    private int size;
    private final Lock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();

    public Warehouse(int maxSize) {
        this.maxSize = maxSize;
        this.size = 0;
    }

    public void put(int item) throws InterruptedException {
        lock.lock();
        try {
            // 如果仓库已满，等待直到有空间可用
            while (size == maxSize) {
                notFull.await();
            }
            // 添加物品
            size++;
            System.out.println("Produced item: " + item);
            // 唤醒等待的消费者
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    public int take() throws InterruptedException {
        lock.lock();
        try {
            // 如果仓库为空，等待直到有物品可用
            while (size == 0) {
                notEmpty.await();
            }
            // 移除物品
            size--;
            int item = ThreadLocalRandom.current().nextInt(100);
            System.out.println("Consumed item: " + item);
            // 唤醒等待的生产者
            notFull.signal();
            return item;
        } finally {
            lock.unlock();
        }
    }
}

生产者和消费者线程

接下来，我们创建生产者和消费者的线程类。

public class Producer implements Runnable {
    private final Warehouse warehouse;

    public Producer(Warehouse warehouse) {
        this.warehouse = warehouse;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                warehouse.put(i);
                Thread.sleep(1000); // 模拟生产过程
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Producer interrupted");
            }
        }
    }
}

public class Consumer implements Runnable {
    private final Warehouse warehouse;

    public Consumer(Warehouse warehouse) {
        this.warehouse = warehouse;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                warehouse.take();
                Thread.sleep(1500); // 模拟消费过程
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Consumer interrupted");
            }
        }
    }
}

主函数

最后，我们在主函数中创建生产者和消费者线程，并启动它们。

public class Main {
    public static void main(String[] args) {
        Warehouse warehouse = new Warehouse(5);

        Thread producerThread = new Thread(new Producer(warehouse), "Producer");
        Thread consumerThread = new Thread(new Consumer(warehouse), "Consumer");

        producerThread.start();
        consumerThread.start();
    }
}

示例说明

1. Lock 和 Condition:

   • 使用 ReentrantLock 创建一个可重入锁。
   • 通过 lock.newCondition() 创建两个 Condition 对象，分别用于控制生产者和消费者的等待条件。

2. 生产者:

   • 在 put 方法中，当仓库已满时，生产者将等待 notFull 条件被信号唤醒。
   • 生产者添加物品后，唤醒等待的消费者。

3. 消费者:

   • 在 take 方法中，当仓库为空时，消费者将等待 notEmpty 条件被信号唤醒。
   • 消费者移除物品后，唤醒等待的生产者。

通过这种方式，生产者和消费者之间可以很好地协同工作，避免了死锁的风险，并且提供了更灵活的线程控制手段。