// ========== 阻塞 ==========

void await() throws InterruptedException; // 造成當前執行緒在接到訊號或被中斷之前一直處於等待狀態。
void awaitUninterruptibly(); // 造成當前執行緒在接到訊號之前一直處於等待狀態。【注意：該方法對中斷不敏感】。
long awaitNanos(long nanosTimeout) throws InterruptedException; // 造成當前執行緒在接到訊號、被中斷或到達指定等待時間之前一直處於等待狀態。返回值表示剩餘時間，如果在`nanosTimeout` 之前喚醒，那麼返回值 `= nanosTimeout - 消耗時間` ，如果返回值 `<= 0` ,則可以認定它已經超時了。
boolean await(long time, TimeUnit unit) throws InterruptedException; // 造成當前執行緒在接到訊號、被中斷或到達指定等待時間之前一直處於等待狀態。
boolean awaitUntil(Date deadline) throws InterruptedException; // 造成當前執行緒在接到訊號、被中斷或到達指定最後期限之前一直處於等待狀態。如果沒有到指定時間就被通知，則返回 true ，否則表示到了指定時間，返回返回 false 。

// ========== 喚醒 ==========

void signal(); // 喚醒一個等待執行緒。該執行緒從等待方法返回前必須獲得與Condition相關的鎖。
void signalAll(); // 喚醒所有等待執行緒。能夠從等待方法返回的執行緒必須獲得與Condition相關的鎖。

public class ConditionObject implements Condition, java.io.Serializable {
    /** First node of condition queue. */
    private transient Node firstWaiter; // 頭節點
    /** Last node of condition queue. */
    private transient Node lastWaiter; // 尾節點
    
    public ConditionObject() {
    }

    // ... 省略內部程式碼
}

public final void await() throws InterruptedException {
    // 當前執行緒中斷
    if (Thread.interrupted())
        throw new InterruptedException();
    //當前執行緒加入等待佇列
    Node node = addConditionWaiter();
    //釋放鎖
    long 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);
}

private Node addConditionWaiter() {
    Node t = lastWaiter;    //尾節點
    //Node的節點狀態如果不為CONDITION，則表示該節點不處於等待狀態，需要清除節點
    if (t != null && t.waitStatus != Node.CONDITION) {
        //清除條件佇列中所有狀態不為Condition的節點
        unlinkCancelledWaiters();
        t = lastWaiter;
    }
    //當前執行緒新建節點，狀態 CONDITION
    Node node = new Node(Thread.currentThread(), Node.CONDITION);
    /**
     * 將該節點加入到條件佇列中最後一個位置
     */
    if (t == null)
        firstWaiter = node;
    else
        t.nextWaiter = node;
    lastWaiter = node;
    return node;
}

final long fullyRelease(Node node) {
    boolean failed = true;
    try {
        // 節點狀態--其實就是持有鎖的數量
        long savedState = getState();
        // 釋放鎖
        if (release(savedState)) {
            failed = false;
            return savedState;
        } else {
            throw new IllegalMonitorStateException();
        }
    } finally {
        if (failed)
            node.waitStatus = Node.CANCELLED;
    }
}

final boolean isOnSyncQueue(Node node) {
    // 狀態為 Condition，獲取前驅節點為 null ，返回 false
    if (node.waitStatus == Node.CONDITION || node.prev == null)
        return false;
    // 後繼節點不為 null，肯定在 CLH 同步佇列中
    if (node.next != null)
        return true;

    return findNodeFromTail(node);
}

// 等待佇列是一個單向連結串列，遍歷連結串列將已經取消等待的節點清除出去
// 純屬連結串列操作，很好理解，看不懂多看幾遍就可以了
private void unlinkCancelledWaiters() {
    Node t = firstWaiter;
    Node trail = null; // 用於中間不需要跳過時，記錄上一個 Node 節點
    while (t != null) {
        Node next = t.nextWaiter;
        // 如果節點的狀態不是 Node.CONDITION 的話，這個節點就是被取消的
        if (t.waitStatus != Node.CONDITION) {
            t.nextWaiter = null;
            if (trail == null)
                firstWaiter = next;
            else
                trail.nextWaiter = next;
            if (next == null)
                lastWaiter = trail;
        }
        else
            trail = t;
        t = next;
    }
}

public final void signal() {
    //檢測當前執行緒是否為擁有鎖的獨
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    //頭節點，喚醒條件佇列中的第一個節點
    Node first = firstWaiter;
    if (first != null)
        doSignal(first);    //喚醒
}

public class ConditionTest {
    private LinkedList<String> buffer;    //容器
    private int maxSize ;           //容器最大
    private Lock lock;
    private Condition fullCondition;
    private Condition notFullCondition;

    ConditionTest(int maxSize){
        this.maxSize = maxSize;
        buffer = new LinkedList<String>();
        lock = new ReentrantLock();
        fullCondition = lock.newCondition();
        notFullCondition = lock.newCondition();
    }

    public void set(String string) throws InterruptedException {
        lock.lock();    //獲取鎖
        try {
            while (maxSize == buffer.size()){
                notFullCondition.await();       //滿了，新增的執行緒進入等待狀態
            }

            buffer.add(string);
            fullCondition.signal();
        } finally {
            lock.unlock();      //記得釋放鎖
        }
    }

    public String get() throws InterruptedException {
        String string;
        lock.lock();
        try {
            while (buffer.size() == 0){
                fullCondition.await();
            }
            string = buffer.poll();
            notFullCondition.signal();
        } finally {
            lock.unlock();
        }
        return string;
    }
}