ps：從北京到杭州可以有不同的路線，這些路線就好比多個線程，在路上可能因為各種原因停停走走，這就好比是線程的等待和通知。
Condition條件：
使用sychronized關鍵字來保證線程的同步時，需要wait()和notify()來保證線程間的通信；而使用重入鎖時，則需要通過Condition來使線程等待和繼續執行。
await(): 使當前線程等待，同時釋放當前鎖，當在其他線程中使用signal()或者signalAll()方法時，線程會重新獲得鎖並繼續執行。也可響應中斷跳出等待，類似於Object.wait()方法。
awaitUninterruptibly(): 與await()方法基本相同，但是它不會響應中斷。
signal(): 喚醒一個等待中的進程。
signalAll()：喚醒所有等待中的進程。

public class LockCondition  implements Runnable{
    //鎖的聲明
    public static ReentrantLock lock = new ReentrantLock();
    public static Condition condition = lock.newCondition();

    @Override
    public void run(){
        try{
            lock.lock();    //和object.wait()類似，在執行await()前，需要線程持有相關重入鎖
 

            condition.await();
            System.out.println("Thread is going on ");
        }catch(InterruptedException e){

        }finally{
            lock.unlock();
        }
    }
    public static void main(){
        LockCondition t1 =new LockCondition();
        Thread t = new Thread(t1);
        t.start();
        Thread.sleep(
 
10000);
        lock.lock();    //和object.notify()類似，在執行signal()前，需要線程持有相關重入鎖
        condition.signal();
        lock.unlock();
    }
}

信號量(Semaphore):
允許多個線程同時訪問臨界區資源。
public Semaphore(int permits);//傳入一個整型值，表示同時允許訪問的線程數。
public Semaphore(int permits,boolean fair)//指定是否公平

信號量的主要方法有：
public void acquire();//獲得一個準入許可
public void acquireUninterruptibly();獲得一個準入許可，但不響應中斷
public boolean tryAcquire();嘗試獲得許可，成功返回true,失敗返回false;
public boolean tryAcquire(long timout,TimeUnit unit);在時限內嘗試獲得許可
public void release();線程訪問資源結束後 ，釋放許可

讀寫鎖(ReadWriteLock)
讀操作和寫操作之間相互阻塞，寫操作和寫操作之間相互阻塞，讀操作和讀操作之間不阻塞。下例啟動了18個讀線程，2個寫線程，可以分別使用普通鎖和讀寫鎖，可以從結果看出讀寫鎖耗時要遠遠低於普通鎖

public class ReadWriteLockDemo {
    private static Lock lock = new ReentrantLock();
    private static ReentrantReadWriteLock readWriteLock =new ReentrantReadWriteLock();
    private static Lock readLock = readWriteLock.readLock();        //聲明讀鎖
    private static Lock writeLock = readWriteLock.writeLock();        //聲明寫鎖
    private int value;
    public Object handleRead(Lock lock) throws InterruptedException {
        try {
            lock.lock();
            Thread.sleep(1000);
            return value;
        }finally {
            lock.unlock();
        }
    }
    public void handleWrite(Lock lock,int index) throws InterruptedException {
        try {
            lock.lock();
            Thread.sleep(1000);
            value = index;
        }finally {
            lock.unlock();
        }
    }
    public static void main(String[] args) {
        final ReadWriteLockDemo demo = new ReadWriteLockDemo();
        
        Runnable readRunnable = new Runnable() {
            public void run() {
                try {
                    demo.handleRead(readLock);    //使用讀寫鎖
                    //demo.handleRead(lock);    //使用普通鎖
                }catch(InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        Runnable writeRunnable = new Runnable() {
            public void run() {
                try {
                    demo.handleWrite(writeLock,new Random().nextInt());    //使用讀寫鎖
                    //demo.handleRead(lock,new Random().nextInt());        //使用普通鎖
                }catch(InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        
        for(int i=0;i<18;i++) {
            new Thread(readRunnable).start();
        }
        for(int i=18;i<20;i++) {
            new Thread(writeRunnable).start();
        }
    }
}

-----------------------------------------------------《實戰Java高並發設計》筆記------------------------------------------------------

JDK並發包--Condition，Semaphore，ReadWriteLock