// 造成當前(qian)線程在接到(dao)信號或被(bei)中(zhong)斷(duan)之前(qian)一直處于等(deng)待狀態(tai)。
void await()
// 造成當前線程在接到信號(hao)、被中斷或到達(da)指定(ding)等待(dai)時間之前一直處于等待(dai)狀態(tai)。
boolean await(long time, TimeUnit unit)
// 造成當前線程在接(jie)到(dao)信(xin)號、被中(zhong)斷或(huo)到(dao)達指定等(deng)待時間之前一直處于(yu)等(deng)待狀態。
long awaitNanos(long nanosTimeout)
// 造(zao)成(cheng)當前(qian)(qian)線程在接到(dao)信號之前(qian)(qian)一直處于等待狀態(tai)。
void awaitUninterruptibly()
// 造成(cheng)當前(qian)線程在接到(dao)信號、被中斷(duan)或到(dao)達指定最后(hou)期限之前(qian)一直處于等(deng)待狀態。
boolean awaitUntil(Date deadline)
// 喚醒一個等待線程。
void signal()
// 喚醒所有等待線程。
void signalAll()

public class WaitTest1 {

    public static void main(String[] args) {

        ThreadA ta = new ThreadA("ta");

        synchronized(ta) { // 通過synchronized(ta)獲取“對象ta的(de)同(tong)步鎖(suo)”
            try {
                System.out.println(Thread.currentThread().getName()+" start ta");
                ta.start();

                System.out.println(Thread.currentThread().getName()+" block");
                ta.wait();    // 等待

                System.out.println(Thread.currentThread().getName()+" continue");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class ThreadA extends Thread{

        public ThreadA(String name) {
            super(name);
        }

        public void run() {
            synchronized (this) { // 通過(guo)synchronized(this)獲取“當前對象的同(tong)步(bu)鎖”
                System.out.println(Thread.currentThread().getName()+" wakup others");
                notify();    // 喚醒(xing)“當前(qian)對象上的(de)等待線程(cheng)”
            }
        }
    }
}

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

public class ConditionTest1 {
        
    private static Lock lock = new ReentrantLock();
    private static Condition condition = lock.newCondition();

    public static void main(String[] args) {

        ThreadA ta = new ThreadA("ta");

        lock.lock(); // 獲取鎖
        try {
            System.out.println(Thread.currentThread().getName()+" start ta");
            ta.start();

            System.out.println(Thread.currentThread().getName()+" block");
            condition.await();    // 等待

            System.out.println(Thread.currentThread().getName()+" continue");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();    // 釋放鎖
        }
    }

    static class ThreadA extends Thread{

        public ThreadA(String name) {
            super(name);
        }

        public void run() {
            lock.lock();    // 獲取鎖(suo)
            try {
                System.out.println(Thread.currentThread().getName()+" wakup others");
                condition.signal();    // 喚醒“condition所在鎖上的(de)其(qi)它線程”
            } finally {
                lock.unlock();    // 釋放鎖
            }
        }
    }
}

main start ta
main block
ta wakup others
main continue

              Object      Condition  
休眠          wait        await
喚醒個線程     notify      signal
喚醒所有線程   notifyAll   signalAll

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

class BoundedBuffer {
    final Lock lock = new ReentrantLock();
    final Condition notFull  = lock.newCondition(); 
    final Condition notEmpty = lock.newCondition(); 

    final Object[] items = new Object[5];
    int putptr, takeptr, count;

    public void put(Object x) throws InterruptedException {
        lock.lock();    //獲(huo)取(qu)鎖
        try {
            // 如果“緩(huan)(huan)沖(chong)已滿”，則(ze)等待；直到(dao)“緩(huan)(huan)沖(chong)”不(bu)是滿的(de)，才將x添(tian)加到(dao)緩(huan)(huan)沖(chong)中。
            while (count == items.length)
                notFull.await();
            // 將x添加到緩沖中
            items[putptr] = x; 
            // 將(jiang)“put統計數putptr+1”；如果“緩沖已滿”，則設putptr為0。
            if (++putptr == items.length) putptr = 0;
            // 將“緩沖”數量+1
            ++count;
            // 喚醒take線程，因為take線程通過notEmpty.await()等(deng)待
            notEmpty.signal();

            // 打印(yin)寫入的數據
            System.out.println(Thread.currentThread().getName() + " put  "+ (Integer)x);
        } finally {
            lock.unlock();    // 釋放鎖
        }
    }

    public Object take() throws InterruptedException {
        lock.lock();    //獲取鎖
        try {
            // 如果(guo)“緩沖為(wei)空(kong)”，則等待；直到“緩沖”不為(wei)空(kong)，才將x從(cong)緩沖中(zhong)取出(chu)。
            while (count == 0) 
                notEmpty.await();
            // 將x從緩沖中取出(chu)
            Object x = items[takeptr]; 
            // 將“take統計數takeptr+1”；如(ru)果“緩沖為空”，則設takeptr為0。
            if (++takeptr == items.length) takeptr = 0;
            // 將“緩(huan)沖(chong)”數(shu)量(liang)-1
            --count;
            // 喚醒put線程，因(yin)為put線程通過(guo)notFull.await()等待
            notFull.signal();

            // 打印取(qu)出的數據
            System.out.println(Thread.currentThread().getName() + " take "+ (Integer)x);
            return x;
        } finally {
            lock.unlock();    // 釋放鎖
        }
    } 
}

public class ConditionTest2 {
    private static BoundedBuffer bb = new BoundedBuffer();

    public static void main(String[] args) {
        // 啟動10個“寫(xie)(xie)線程”，向BoundedBuffer中不斷的寫(xie)(xie)數(shu)據(寫(xie)(xie)入0-9)；
        // 啟動10個“讀(du)線(xian)程”，從BoundedBuffer中不斷(duan)的讀(du)數據。
        for (int i=0; i<10; i++) {
            new PutThread("p"+i, i).start();
            new TakeThread("t"+i).start();
        }
    }

    static class PutThread extends Thread {
        private int num;
        public PutThread(String name, int num) {
            super(name);
            this.num = num;
        }
        public void run() {
            try {
                Thread.sleep(1);    // 線程休眠1ms
                bb.put(num);        // 向BoundedBuffer中寫(xie)入數(shu)據
            } catch (InterruptedException e) {
            }
        }
    }

    static class TakeThread extends Thread {
        public TakeThread(String name) {
            super(name);
        }
        public void run() {
            try {
                Thread.sleep(10);                    // 線程休眠(mian)1ms
                Integer num = (Integer)bb.take();    // 從(cong)BoundedBuffer中取(qu)出數據
            } catch (InterruptedException e) {
            }
        }
    }
}

p1 put  1
p4 put  4
p5 put  5
p0 put  0
p2 put  2
t0 take 1
p3 put  3
t1 take 4
p6 put  6
t2 take 5
p7 put  7
t3 take 0
p8 put  8
t4 take 2
p9 put  9
t5 take 3
t6 take 6
t7 take 7
t8 take 8
t9 take 9

     1, p1線程向緩沖中寫入1。    此時，緩沖區數據:   | 1 |   |   |   |   |
     2, p4線程向緩沖中寫入4。    此時，緩沖區數據:   | 1 | 4 |   |   |   |
     3, p5線程向緩沖中寫入5。    此時，緩沖區數據:   | 1 | 4 | 5 |   |   |
     4, p0線程向緩沖中寫入0。    此時，緩沖區數據:   | 1 | 4 | 5 | 0 |   |
     5, p2線程向緩沖中寫入2。    此時，緩沖區數據:   | 1 | 4 | 5 | 0 | 2 |
     此(ci)時(shi)，緩(huan)沖區(qu)容量為(wei)5；緩(huan)沖區(qu)已滿(man)！如果此(ci)時(shi)，還有“寫(xie)線程”想往緩(huan)沖中寫(xie)入數(shu)據(ju)，會調用put中的notFull.await()等(deng)待，直接(jie)緩(huan)沖區(qu)非滿(man)狀態，才能繼續運行。
     6, t0線程從緩沖中取出數據1。此時，緩沖區數據:   |   | 4 | 5 | 0 | 2 |
     7, p3線程向緩沖中寫入3。    此時，緩沖區數據:   | 3 | 4 | 5 | 0 | 2 |
     8, t1線程從緩沖中取出數據4。此時，緩沖區數據:   | 3 |   | 5 | 0 | 2 |
     9, p6線程向緩沖中寫入6。    此時，緩沖區數據:   | 3 | 6 | 5 | 0 | 2 |
     ...