使用Lock來實現生產者和消費者問題

前面寫過：synchronize來實現生產者和消費者問題

現在用Lock來實現它

package com.thread;

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


/**
 * 使用Lock來實現生產者和消費者問題
 * 
 * @author 劉玲
 *
 */
public class ProducerConsumer {
    public static void main(String[] args) {
        Basket b = new Basket();
        Product p = new Product(b);
        Consumer c = new Consumer(b);
        Consumer c1 = new Consumer(b);
        new Thread(p).start();
        new Thread(c).start();
        new Thread(c1).start();
    }
}
//饅頭
class ManTou{
    int id;
    public ManTou(int id) {
        this.id = id;
    }
    @Override
    public String toString() {
        return "ManTou"+id;
    }
}

//裝饅頭的籃子
class Basket{
    int max = 6;
    LinkedList<ManTou> manTous = new LinkedList<ManTou>();
    Lock lock = new ReentrantLock(); //鎖對象
    Condition full = lock.newCondition();  //用來監控籃子是否滿的Condition實例
    Condition empty = lock.newCondition(); //用來監控籃子是否空的Condition實例
    //往籃子里面放饅頭
    public void push(ManTou m){
        lock.lock();
        try {
            while(max == manTous.size()){
                System.out.println("籃子是滿的，待會兒再生產...");
                full.await();
            }
            manTous.add(m);
            empty.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    }
    //往籃子里面取饅頭
    public ManTou pop(){
        ManTou m = null;
        lock.lock();
        try {
            while(manTous.size() == 0){
                System.out.println("籃子是空的，待會兒再吃...");
                empty.await();
            }
            m = manTous.removeFirst();
            full.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            lock.unlock();
            return m;
        }
    }
}
//生產者
class Product implements Runnable{
    Basket basket;
    public Product(Basket basket) {
        this.basket = basket;
    }
    public void run() {
        for (int i = 0; i < 40; i++) {
            ManTou m = new ManTou(i);
            basket.push(m);
            System.out.println("生產了"+m);
            try {
                Thread.sleep((int)(Math.random()*2000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
        }
    }
}

//消費者
class Consumer implements Runnable{
    Basket basket;
    public Consumer(Basket basket) {
        this.basket = basket;
    }
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep((int)(Math.random()*2000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ManTou m = basket.pop();
            System.out.println("消費了"+m);
        }
    }
}

 附：synchronize與Lock的區別

一、synchronized和lock的用法區別
 
synchronized：在需要同步的對象中加入此控制，synchronized可以加在方法上，也可以加在特定代碼塊中，括號中表示需要鎖的對象。
 
lock：需要顯示指定起始位置和終止位置。一般使用ReentrantLock類做為鎖，多個線程中必須要使用一個ReentrantLock類做為對象才能保證鎖的生效。且在加鎖和解鎖處需要通過lock()和unlock()顯示指出。所以一般會在finally塊中寫unlock()以防死鎖。
 
用法區別比較簡單，這里不贅述了，如果不懂的可以看看Java基本語法。
 
二、synchronized和lock性能區別
 
synchronized是托管給JVM執行的，而lock是java寫的控制鎖的代碼。在Java1.5中，synchronize是性能低效的。因為這是一個重量級操作，需要調用操作接口，導致有可能加鎖消耗的系統時間比加鎖以外的操作還多。相比之下使用Java提供的Lock對象，性能更高一些。但是到了Java1.6，發生了變化。synchronize在語義上很清晰，可以進行很多優化，有適應自旋，鎖消除，鎖粗化，輕量級鎖，偏向鎖等等。導致在Java1.6上synchronize的性能並不比Lock差。官方也表示，他們也更支持synchronize，在未來的版本中還有優化余地。
 
說到這里，還是想提一下這2中機制的具體區別。據我所知，synchronized原始采用的是CPU悲觀鎖機制，即線程獲得的是獨占鎖。獨占鎖意味着其他線程只能依靠阻塞來等待線程釋放鎖。而在CPU轉換線程阻塞時會引起線程上下文切換，當有很多線程競爭鎖的時候，會引起CPU頻繁的上下文切換導致效率很低。
 
而Lock用的是樂觀鎖方式。所謂樂觀鎖就是，每次不加鎖而是假設沒有沖突而去完成某項操作，如果因為沖突失敗就重試，直到成功為止。樂觀鎖實現的機制就是CAS操作（Compare and Swap）。我們可以進一步研究ReentrantLock的源代碼，會發現其中比較重要的獲得鎖的一個方法是compareAndSetState。這里其實就是調用的CPU提供的特殊指令。
 
現代的CPU提供了指令，可以自動更新共享數據，而且能夠檢測到其他線程的干擾，而 compareAndSet() 就用這些代替了鎖定。這個算法稱作非阻塞算法，意思是一個線程的失敗或者掛起不應該影響其他線程的失敗或掛起的算法。
 
我也只是了解到這一步，具體到CPU的算法如果感興趣的讀者還可以在查閱下，如果有更好的解釋也可以給我留言，我也學習下。
 
三、synchronized和lock用途區別
 
synchronized原語和ReentrantLock在一般情況下沒有什么區別，但是在非常復雜的同步應用中，請考慮使用ReentrantLock，特別是遇到下面2種需求的時候。
 
1.某個線程在等待一個鎖的控制權的這段時間需要中斷
2.需要分開處理一些wait-notify，ReentrantLock里面的Condition應用，能夠控制notify哪個線程
3.具有公平鎖功能，每個到來的線程都將排隊等候