摘要：提供了多線程升級方案將同步替換成了顯示的操作。線程間通信接口可以替代傳統的線程間通信，用替換，用替換，用替換。商品執行上述代碼，觀察結果可以看到，多個線程同時生產消費，由于指定喚醒互異線程，因此并不會引起錯誤。

JDK 1.5提供了多線程升級方案
將同步synchronized替換成了顯示的Lock操作?？梢詫崿F喚醒、凍結指定的線程。

Lock接口
Lock 實現提供了比使用 synchronized 方法和語句可獲得的更廣泛的鎖定操作。此實現允許更靈活的結構，可以具有差別很大的屬性，可以支持多個相關的 Condition 對象。
線程間通信Condition接口
Condition可以替代傳統的線程間通信，用await()替換wait()，用signal()替換notify()，用signalAll()替換notifyAll()。該對象可以通過Lock鎖進行獲取。

傳統線程的通信方式，Condition都可以實現。

注意，Condition是被綁定到Lock上的，要創建一個Lock的Condition必須用newCondition()方法。
ReentrantLock類
Java.util.concurrent.lock 中的Lock 框架是鎖定的一個抽象，它允許把鎖定的實現作為 Java 類，而不是作為語言的特性來實現。這就為Lock 的多種實現留下了空間，各種實現可能有不同的調度算法、性能特性或者鎖定語義。

ReentrantLock 類實現了Lock ，它擁有與synchronized 相同的并發性和內存語義，但是添加了類似鎖投票、定時鎖等候和可中斷鎖等候的一些特性。此外，它還提供了在激烈爭用情況下更佳的性能。（換句話說，當許多線程都想訪問共享資源時，JVM 可以花更少的時候來調度線程，把更多時間用在執行線程上。）

用法示例：

private Lock lock = new ReentrantLock();//定義多態ReentrantLock類對象
private Condition cond_pro = lock.newCondition();//Condition是被綁定到Lock上的，要創建一個Lock的Condition必須用Lock對象的newCondition()方法。
private Condition cond_con = lock.newCondition();//一個lock可以有多個相關的condition

首先創建一個ReentrantLock類的多態對象，即建立一把鎖。然后將這把鎖與兩個Condition對象關聯。

實例：

import java.util.concurrent.locks.*;
    class ProducerConsumerDemo 
    {
        public static void main(String[] args) 
        {
            Resource r = new Resource();
            Producer pro = new Producer(r);//生產者對象
            Consumer con = new Consumer(r);//消費者對象
    
            Thread t1 = new Thread(pro);
            Thread t2 = new Thread(pro);
            Thread t3 = new Thread(con);
            Thread t4 = new Thread(con);
    
            t1.start();
            t2.start();
            t3.start();    
            t4.start();    
            }
    }
    
    class Resource
    {
        private String name;
        private int count = 1;
        private boolean flag = false;
        private Lock lock = new ReentrantLock();//定義一個實現Lock接口的ReentrantLock類對象
        private Condition cond_pro = lock.newCondition();//Condition是被綁定到Lock上的，要創建一個Lock的Condition必須用Lock對象的newCondition()方法。
           private Condition cond_con = lock.newCondition();//一個lock可以有多個相關的condition
        
        public  void set(String name) throws InterruptedException//生產方法
                                       //注意這里拋出await（）方法異常聲明，交給調用者處理
        {
            lock.lock();    //手動加同步鎖
            try
            {  
                while (flag)    //if→while 此時若生產完一個以后喚醒了另一個生產者，則再次判斷，避免了兩個生產者同時生產
                    cond_pro.await();       //凍結生產方法
                this.name = name+"____"+count++;
                System.out.println(Thread.currentThread().getName()+"_______"+"生產者"+this.name);
                flag = true;
                cond_con.signal(); //喚醒消費方法，利用了condition的signal()指定喚醒對象        
            }
            finally    //
            {
                lock.unlock();
            }
        }
    
        public  void out()throws InterruptedException
        {
            lock.lock();
            try
                {
                    while (!flag)
                        cond_con.await();
                    System.out.println(Thread.currentThread().getName()+"______"+"消費者"+this.name);
                    flag = false;
                    cond_pro.signal();
                }

            finally    //釋放鎖必須得到執行
            {
                lock.unlock();
            }
        }
    }
    
    class Consumer implements Runnable
    {
        private Resource res;
        public Consumer(Resource res)
        {
            this.res = res;
        }
        public void run()
        {
            while (true)
            {
                try    //由于out（）方法拋出了異常聲明，這里必須捕獲。
                {
                    res.out();
    
                }
                catch (InterruptedException e)
                {
                }
            }
            
        }
    }
    
    class Producer implements Runnable
    {
        private Resource res;
        public Producer(Resource res)
        {
        
                this.res = res;                
            
        }

        public void run()
        {
            while (true)
            {    
                try
                {
                    res.set("+商品+");
                
                }
                catch (InterruptedException e)
                {
                }
            }
    
        }
    }

執行上述代碼，觀察結果：

可以看到，多個線程同時生產、消費，由于指定喚醒互異線程，因此并不會引起錯誤。