Java線程：並發協作-生產者消費者模型

標籤：多線程   程式設計語言   並發   java   線程   

對於多線程程式來說，不管任何程式設計語言，生產者消費者模型都是最經典的。
實際上，準確的說應該是“生產者-消費者-倉儲”模型，離開了倉儲，生產者消費者模型就顯得沒有說服力了。
對於此模型，應該明確以下幾點：

1. 生產者僅僅在倉儲未滿時候生產，倉滿則停止生產。
2. 消費者僅僅在倉儲有產品時候才能消費，倉空則等待。
3. 當消費者發現倉儲沒有產品的時候會通知生產者生產。
4. 生產者在生產出可消費產品時候，應該通知消費者去消費。

此模型將要結合java.lang.Object的wait與notify，notifyAll方法來實現以上的需求。這是非常重要的。
用代碼實現如下：

class Godown{    public static final int max_size = 100 ;//最大庫存量    public int curnum ; //當前庫存量    public Godown() {        // TODO 自動產生的建構函式存根    }    public Godown(int curnum){        this.curnum = curnum;    }    public synchronized void produce(int neednum){ //生產指定數量的產品         while((neednum+curnum)>max_size){//檢測是否需要生產            System.out.println("要生產的產品數量"+neednum+"超過剩餘庫存量"+(max_size-curnum)+",暫時不能執行生產任務1");             try{                 //當前的生產線程等待                 wait();             }catch (InterruptedException e){                 e.printStackTrace();             }        }        //滿足生產條件，則進行生產，更改當前庫存量        curnum += neednum;        System.out.println("已經生產了"+neednum+"個產品，現倉儲量為"+curnum);        //喚醒在此對象監視器上等待的所有線程        notifyAll();        }    public synchronized void consume(int neednum){        while((curnum<neednum)) { //檢測是否可以消費            try{                //當前的生產線程等待                wait();            }catch(InterruptedException e){                e.printStackTrace();            }        }//滿足消費條件，則進行消費，即更改當前庫存量        curnum -= neednum;        System.out.println("已經消費了"+neednum+"個產品，現倉儲量為"+curnum);        //喚醒在此監視器上等待的所有線程        notifyAll();    }}

/* 生產者 */class Producer extends Thread{    private int neednum ;     // 生產產品數量    private Godown godown;   //倉庫    public Producer(int neednum,Godown godown) {        // TODO 自動產生的建構函式存根        this.neednum = neednum ;        this.godown = godown;    }    public void run(){        //生產指定數量的產品        godown.produce(neednum);    }}

/* 消費者 */class Consumer extends Thread{    private int neednum ;  // 生產產品數量    private Godown godown; //倉庫    public Consumer(int needrum,Godown godown) {        // TODO 自動產生的建構函式存根        this.neednum = needrum;        this.godown = godown;    }    public void run(){        //消費指定數量的產品        godown.consume(neednum);    }}

主程式實現代碼：

package com.leetch.Threads;import java.lang.*; public class Test {    public static void main(String args[]){        Godown godown = new Godown(30);        Consumer c1 = new Consumer(50,godown) ;        Consumer c2 = new Consumer(20, godown);        Consumer c3 = new Consumer(30, godown);        Producer p1 = new Producer(10, godown);        Producer p2 = new Producer(10, godown);        Producer p3 = new Producer(10, godown);        Producer p4 = new Producer(10, godown);        Producer p5 = new Producer(10, godown);        Producer p6 = new Producer(10, godown);        c1.start();        c2.start();        c3.start();        p1.start();        p2.start();        p3.start();        p4.start();        p5.start();        p6.start();    }}

一次執行結果如下：

說明：
對於本例，要說明的是當發現不能滿足生產或者消費條件的時候，調用對象的wait( )方法，wait方法的作用是釋放當前線程所獲得的鎖，並調用對象的notifyAll()方法，通知（喚醒）該對象上其他等待線程，使得繼續執行。這樣，整個生產者，消費者線程得以正確的協作執行。
nitifyAll()方法，起到一個通知作用，不釋放鎖，也不擷取鎖，只是告訴該對象上等待的線程“可以競爭執行了，都去執行吧！”。
本例中，如果消費者消費的倉儲量達不到滿足，而又沒有生產者，則進程會一直處於等待狀態，這當然是不對的，實際上可以將此例進行修改，修改為根據消費驅動生產，同時生產兼顧倉庫，如果倉不滿就生產，並對每次最大消費量做個限制，這樣就不存在此問題了，當然，這樣的例子更加複雜。
Java線程：並發協作-死結
線程發生死結可能性很小，即使看似可能發生死結的代碼，在運行時發生死結的可能性也是小之又小。
發生死結的原因一般是兩個對象的鎖相互等待造成的。
例如：

public class Test {         public static void main(String[] args) {                 DeadlockRisk dead = new DeadlockRisk();                 MyThread t1 = new MyThread(dead, 1, 2);                 MyThread t2 = new MyThread(dead, 3, 4);                 MyThread t3 = new MyThread(dead, 5, 6);                 MyThread t4 = new MyThread(dead, 7, 8);                 t1.start();                 t2.start();                 t3.start();                 t4.start();         } } class MyThread extends Thread {         private DeadlockRisk dead;         private int a, b;         MyThread(DeadlockRisk dead, int a, int b) {                 this.dead = dead;                 this.a = a;                 this.b = b;         }         @Override         public void run() {                 dead.read();                 dead.write(a, b);         } } class DeadlockRisk {         private static class Resource {                 public int value;         }         private Resource resourceA = new Resource();         private Resource resourceB = new Resource();         public int read() {                 synchronized (resourceA) {                         System.out.println("read():" + Thread.currentThread().getName() + "擷取了resourceA的鎖！");                         synchronized (resourceB) {                                 System.out.println("read():" + Thread.currentThread().getName() + "擷取了resourceB的鎖！");                                 return resourceB.value + resourceA.value;                         }                 }         }         public void write(int a, int b) {                 synchronized (resourceB) {                         System.out.println("write():" + Thread.currentThread().getName() + "擷取了resourceA的鎖！");                         synchronized (resourceA) {                                 System.out.println("write():" + Thread.currentThread().getName() + "擷取了resourceB的鎖！");                                 resourceA.value = a;                                 resourceB.value = b;                         }                 }         } }

Java線程：並發協作-生產者消費者模型