// 造成當(dāng)前線程在接到信號(hào)或被中斷之前一直處于等待狀態(tài)。
void await()
// 造成當(dāng)前線程在接到信號(hào)、被中斷或到達(dá)指定等待時(shí)間之前一直處于等待狀態(tài)。
boolean await(long time, TimeUnit unit)
// 造成當(dāng)前線程在接到信號(hào)、被中斷或到達(dá)指定等待時(shí)間之前一直處于等待狀態(tài)。
long awaitNanos(long nanosTimeout)
// 造成當(dāng)前線程在接到信號(hào)之前一直處于等待狀態(tài)。
void awaitUninterruptibly()
// 造成當(dāng)前線程在接到信號(hào)、被中斷或到達(dá)指定最后期限之前一直處于等待狀態(tài)。
boolean awaitUntil(Date deadline)
// 喚醒一個(gè)等待線程。
void signal()
// 喚醒所有等待線程。
void signalAll()

public class WaitTest1 {
  public static void main(String[] args) {
    ThreadA ta = new ThreadA("ta");
    synchronized(ta) { // 通過(guò)synchronized(ta)獲取“對(duì)象ta的同步鎖”
      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) { // 通過(guò)synchronized(this)獲取“當(dāng)前對(duì)象的同步鎖”
        System.out.println(Thread.currentThread().getName()+" wakup others");
        notify();  // 喚醒“當(dāng)前對(duì)象上的等待線程”
      }
    }
  }
}

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();  // 獲取鎖
      try {
        System.out.println(Thread.currentThread().getName()+" wakup others");
        condition.signal();  // 喚醒“condition所在鎖上的其它線程”
      } finally {
        lock.unlock();  // 釋放鎖
      }
    }
  }
}

main start ta
main block
ta wakup others
main continue

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();  //獲取鎖
    try {
      // 如果“緩沖已滿”，則等待；直到“緩沖”不是滿的，才將x添加到緩沖中。
      while (count == items.length)
        notFull.await();
      // 將x添加到緩沖中
      items[putptr] = x; 
      // 將“put統(tǒng)計(jì)數(shù)putptr+1”；如果“緩沖已滿”，則設(shè)putptr為0。
      if (++putptr == items.length) putptr = 0;
      // 將“緩沖”數(shù)量+1
      ++count;
      // 喚醒take線程，因?yàn)閠ake線程通過(guò)notEmpty.await()等待
      notEmpty.signal();
      // 打印寫入的數(shù)據(jù)
      System.out.println(Thread.currentThread().getName() + " put "+ (Integer)x);
    } finally {
      lock.unlock();  // 釋放鎖
    }
  }
  public Object take() throws InterruptedException {
    lock.lock();  //獲取鎖
    try {
      // 如果“緩沖為空”，則等待；直到“緩沖”不為空，才將x從緩沖中取出。
      while (count == 0) 
        notEmpty.await();
      // 將x從緩沖中取出
      Object x = items[takeptr]; 
      // 將“take統(tǒng)計(jì)數(shù)takeptr+1”；如果“緩沖為空”，則設(shè)takeptr為0。
      if (++takeptr == items.length) takeptr = 0;
      // 將“緩沖”數(shù)量-1
      --count;
      // 喚醒put線程，因?yàn)閜ut線程通過(guò)notFull.await()等待
      notFull.signal();
      // 打印取出的數(shù)據(jù)
      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) {
    // 啟動(dòng)10個(gè)“寫線程”，向BoundedBuffer中不斷的寫數(shù)據(jù)(寫入0-9)；
    // 啟動(dòng)10個(gè)“讀線程”，從BoundedBuffer中不斷的讀數(shù)據(jù)。
    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中寫入數(shù)據(jù)
      } catch (InterruptedException e) {
      }
    }
  }
  static class TakeThread extends Thread {
    public TakeThread(String name) {
      super(name);
    }
    public void run() {
      try {
        Thread.sleep(10);          // 線程休眠1ms
        Integer num = (Integer)bb.take();  // 從BoundedBuffer中取出數(shù)據(jù)
      } catch (InterruptedException e) {
      }
    }
  }
}