深入理解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()

SQL優化-20231016

深入理解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以太網驅動總結