深入理解Java并发编程之扣一下Condition

本文转载自个人掘金博客：https://juejin.im/post/5ed9a09a6fb9a047d45ba4b0

前言

本文为《Java并发编程的艺术》第五章第6节的读书笔记。

任意一个Java对象，都拥有一组监视器方法（定义在java.lang.Object上，实际作用于这个对象对应的monitor），主要包括wait()、wait(long timeout)、notify()以及notifyAll()方法，这些方法与synchronized同步关键字配合，可以实现等待/通知模式。Condition接口也提供了类似Object的监视器方法，与Lock配合可以实现等待/通知模式，但是这两者在使用方式以及功能特性上还是有差别的。

Object的监视器方法与Condition接口的对比

通过对比Object的监视器方法和Condition接口，可以更详细地了解Condition的特性，对比项与结果如下表所示：

Condition接口与示例

Condition定义了等待/通知两种类型的方法，当前线程调用这些方法时，需要提前获取到Condition对象关联的锁(Lock.lock())。Condition对象是由Lock对象（调用Lock对象的newCondition()方法）创建出来的，换句话说，Condition是依赖Lock对象的。

Condition的接口方法

Condition的接口方法如下所示：

void await() throws InterruptedException：当前线程进入等待状态直到被通知(signal)或被中断(interrupt)，当前线程将进入运行状态。如果线程从await()方法退出则表明该线程已经获取到了Condition对象对应的锁。从等待状态返回进入运行态的原因包括：
- 其他线程调用该Condition的signal()或者signalAll()方法，而当前线程被选中唤醒。
- 其他线程调用interrupt()方法中断当前线程。
void awaitUninterruptibly()：当前线程进入等待状态直到被通知(signal)，从方法名称上可以看出该方法对中断不敏感。
long awaitNanos(long nanosTimeout) throws InterruptedException：当前线程进入等待状态直到被通知、中断或者超时。返回值表示剩余的时间，如果在nanosTimeout纳秒前被唤醒，那么返回值就是(nanosTimeout - 实际耗时)。如果返回值是0或者负数，就是超时了。
boolean await(long time, TimeUnit unit) throws InterruptedException：这个方法等价于awaitNanos(unit.toNanos(time)) > 0。
boolean awaitUntil(Date deadline) throws InterruptedException：当前线程进入等待状态直到被通知、中断或者某个时间。如果没有到指定时间就被通知，方法返回true，否则，表示到了指定时间，方法返回false。
void signal()：唤醒一个等待在Condition上的线程，该线程从await()方法返回前必须获得与Condition相关联的锁。
void signalAll(): 唤醒所有等待在Condition上的线程，能够从await()方法返回的线程必须获得与Condition相关联的锁。

Condition的使用示例

获取一个Condition必须通过Lock的newCondition()方法。下面通过一个有界队列的示例来深入了解Condition的使用方式。有界队列是一种特殊的队列

当队列为空时，队列的获取操作将会阻塞获取线程，直到队列中有新增元素。
当队列已满时，队列的插入操作将会阻塞插入线程，直到队列出现“空位”。

下面给出基于Condition实现的有界队列实现代码：

public class BoundedQueue<T> {
    private Object[] items;

    // 添加的下标
    private int addIndex;

    // 删除的下标
    private int removeIndex;

    // 数组当前数量
    private int count;

    private Lock lock = new ReentrantLock();

    /**
     * 队列为空时删除操作线程await在notEmpty，
     * 添加操作后队列不空时线程signal notEmpty Condition
     */
    private Condition notEmpty = lock.newCondition();

    /**
     * 队列满了时添加操作线程await在notFull，
     * 删除操作后队列不满时线程signal notFull Condition
     */
    private Condition notFull = lock.newCondition();

    public BoundedQueue(int size) {
        items = new Object[size];
    }

    /**
     * 添加一个元素，如果数组满，则添加线程进入等待状态，知道有"空位"
     */
    public void add(T t) throws InterruptedException {
        lock.lock();

        try {
            while (count == items.length)
                notFull.await();
            items[addIndex] = t;
            addIndex += 1;
            if (addIndex == items.length) {
                addIndex = 0;
            }
            count += 1;
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    /**
     * 由头部删除一个元素，如果数组为空，则删除线程进入等待转态，直到有新添加的元素
     */
    public T remove() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0)
                notEmpty.await();
            Object x = items[removeIndex];
            removeIndex += 1;
            if (removeIndex == items.length) {
                removeIndex = 0;
            }
            --count;
            notFull.signal();
            return (T) x;
        } finally {
            lock.unlock();
        }
    }
}

这里解释下add(T)方法的流程：

首先需要获得锁，目的是确保数组修改的可见性和排他性。同时，进行await()也需要当前线程先获取锁。
如果数组数量等于数组长度时，表示数组已满，则调用notFull.await()，当前线程随之释放锁并进入等待状态。
如果数组数量不等于数组长度，表示数组未满，则添加元素到数组中，同时通知等待在notEmpty上的线程，数组中已经有新元素可以获取。

这里添加和删除方法中使用while循环的目的也是为了防止伪唤醒的情况。这一点也是和线程的等待/通知的经典范式很类似。

下面再给出一个有界队列的测试用例，可以发现其阻塞功能确实ok。

public class BoundedQueueTest {

    @Test
    public void testCase01() throws InterruptedException {
        BoundedQueue<Integer> boundedQueue = new BoundedQueue<>(3);
        for (int i = 0; i < 3; i++) {
            boundedQueue.add(i);
        }

        Thread thread = new Thread(new RunnableRemove(boundedQueue));
        thread.start();

        boundedQueue.add(3);
        System.out.println("Succeed add!");
    }

    @Test
    public void testCase02() throws InterruptedException {
        BoundedQueue<Integer> boundedQueue = new BoundedQueue<>(3);

        Thread thread = new Thread(new RunnableAdd(0, boundedQueue));
        thread.start();

        boundedQueue.remove();
        System.out.println("Succeed remove!");
    }

    static class RunnableAdd implements Runnable {
        int num;
        BoundedQueue<Integer> boundedQueue;

        public RunnableAdd(int num, BoundedQueue<Integer> boundedQueue) {
            this.num = num;
            this.boundedQueue = boundedQueue;
        }

        @Override
        public void run() {
            try {
                System.out.println("New thread add element!");
                Thread.sleep(1000 * 5);
                boundedQueue.add(num);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("add:" + num);
        }
    }

    static class RunnableRemove implements Runnable {
        BoundedQueue<Integer> boundedQueue;

        public RunnableRemove(BoundedQueue<Integer> boundedQueue) {
            this.boundedQueue = boundedQueue;
        }

        @Override
        public void run() {
            try {
                System.out.println("New thread remove element!");
                Thread.sleep(1000 * 5);
                int num = boundedQueue.remove();
                System.out.println("remove:" + num);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Condition的实现分析

ConditionObject是一个实现Condition接口的AQS的静态内部类。每个Condition对象都包含着一个等待队列，该等待队列是Condition对象实现等待/通知功能的关键。

这里以ConditionObject为例来分析Condition接口的实现，主要包括：等待队列、等待和通知。

等待队列

等待队列是一个FIFO的队列，在队列中的每个节点都包含了一个线程引用，该线程就是在ConditionObject对象上等待的线程，如果一个线程调用了Condition.await()方法，那么该线程将会释放锁、构造成节点加入等待队列并进入等待状态。
ConditionObject的节点定义复用了AQS中Node节点的定义。也就是说，同步队列和等待队列中节点类型都是AQS内部类AbstractQueuedSynchronizer.Node。
ConditionObject包含一个等待队列，ConditionObject拥有首节点（firstWaiter）和尾节点（lastWaiter）。当前线程调用Condition.await()方法，将会以当前线程构造节点，并将节点从尾部加入等待队列。
ConditionObject拥有首尾节点的引用，而新增节点只需要将原有的尾节点nextWaiter指向它，并且更新尾节点即可。上述节点引用更新的过程并没有使用CAS保证，原因在于调用await()方法的线程必定是获取了锁的线程，也就是说该过程是由锁来保证线程安全的。

在Object的监视器(Monitor)模型上，一个对象拥有一个同步队列（entry set）和等待队列（wait set），这块内容可参见深入理解Java并发编程之线程Thread。

而对于并发包里面使用AQS并继承Lock接口实现的锁或者是同步组件，则拥有一个同步队列和多个等待队列。一个同步队列指的是AQS中的同步队列，多个等待队列指的是多个ConditionObject对象实例上的等待队列。AQS，同步队列以及等待队列的关系如图所示：

等待await()

调用Condition的await()方法（或者以await开头的方法），会使当前线程进入等待队列并释放锁，同时线程状态变为等待状态。当从await()方法返回时，当前线程一定获取了ConditionObject相关联的锁。

从AQS的同步队列和等待队列的角度看await()方法

调用await()的线程成功获取了锁的线程，也就是同步队列中的首节点，该方法会将当前线程重新构造成节点并加入等待队列中，然后释放同步状态，唤醒同步队列中的后继节点，然后当前线程会进入等待状态。

ConditionObject的await()方法代码如下所示：

        public final void await() throws InterruptedException {
            if (Thread.interrupted())
                throw new InterruptedException();
            // 当前线程加入等待队列    
            Node node = addConditionWaiter();
            // 释放同步状态，也就是释放锁
            int savedState = fullyRelease(node);
            int interruptMode = 0;
            while (!isOnSyncQueue(node)) {
                LockSupport.park(this);
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
            }
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null) // clean up if cancelled
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
        }

同步队列的首节点(包裹了当前线程)并不会直接加入等待队列，而是通过addConditionWaiter()方法把当前线程构造成一个新的节点并将其加入等待队列中。

通知signal()

调用ConditionObject的signal()方法，将会唤醒在等待队列中等待时间最长的节点（首节点），在唤醒节点之前，会将节点移到同步队列中。

ConditionObject的signal()方法如下所示：

        public final void signal() {
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            Node first = firstWaiter;
            if (first != null)
                doSignal(first);
        }

调用signal()方法的前置条件是当前线程必须获取了锁，可以看到signal()方法进行了isHeldExclusively()检查，也就是当前线程必须是获取了锁的线程。
接着获取等待队列的首节点，将其移动到同步队列并使用LockSupport唤醒节点中的线程。
通过调用同步器的enq(Node node)方法，等待队列中的头节点线程安全地移动到同步队列。当节点移动到同步队列后，当前线程再使用LockSupport唤醒该节点的线程。
被唤醒后的线程，将从await()方法中的while循环中退出（isOnSyncQueue(Node node)方法返回true，节点已经在同步队列中），进而调用同步器的acquireQueued()方法加入到获取同步状态的竞争中。
成功获取同步状态（或者说锁）之后，被唤醒的线程将从先前调用的await()方法返回，此时该线程已经成功地获取了锁。

节点从等待队列移动到同步队列的过程如下图所示：

ConditionObject的**signalAll()**方法，相当于对等待队列中的每个节点均执行一次signal()方法，效果就是将等待队列中所有节点全部移动到同步队列中，并唤醒每个节点的线程。

深入理解Java并发编程之扣一下Condition

前言

Object的监视器方法与Condition接口的对比

Condition接口与示例

Condition的接口方法

Condition的使用示例

Condition的实现分析

等待队列

等待await()

通知signal()

《Python进阶》学习笔记

Leetcode 3161. 物块放置查询

leetcode 60 排列序列

一个docker容器暴露多个端口

微服务实践之使用 Visual Studio 2022 调试Dapr 应用程序

wpf附加属性理解 WPF附加属性

深入理解Java併發編程之線程池技術

深入理解Java併發編程之Lock和AQS

深入理解Java併發編程之扣一下Condition

深入理解Java併發編程之線程Thread

深入理解Java併發編程之通過JDK C++源碼以及Debug源碼死扣Thread.join()

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結