生產者消費者之爸爸媽媽兒子女兒蘋果橘子編程實現

生產者消費者之爸爸媽媽兒子女兒蘋果橘子編程實現

桌上有一個空盤子，只容許放一個水果。爸爸能夠向盤中放蘋果，也能夠向盤中放桔子，兒子專等吃盤中的桔子，女兒專等吃盤中的蘋果。規定當盤空時，一次只能放一隻水果。

下面是程序的具體實現代碼，在寫這個程序的時候，有點小問題，糾結了很長時間，因而在csdn論壇上發表帖子終於獲得瞭解決

先說說涉及到的類的做用，首先Fruits做爲一個水果的父類，Apple和Orange是Fruits類的擴展類。CriticalResources類是臨界資源類，做爲緩衝區用，裏面封裝了數組大小爲一的Fruits數組，能夠當作「盤子」；ProducerOrange爲生產橘子的類 ProducerApple爲生產桔子的類 ConsumerApple（消費蘋果的類） ConsumerOrange（消費桔子的類）

水果類代碼以下

package com.bankht.producerCustomer;

public class Fruits {
    private String name;

    public Fruits(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return name;
    }

    public Fruits() {
        super();
    }

}

package com.bankht.producerCustomer;

/**
 * @author zhuyong
 * 建立時間：2012-6-6 上午09:46:14
 * 類說明 ：
 */
public class Orange extends Fruits {

    public Orange() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Orange(String name) {
        super(name);
        // TODO Auto-generated constructor stub
    }

}

package com.bankht.producerCustomer;

/**
 * @author zhuyong
 * 建立時間：2012-6-6 上午09:46:14
 */
public class Apple extends Fruits {

    public Apple() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Apple(String name) {
        super(name);
        // TODO Auto-generated constructor stub
    }

}

下面是做爲緩衝區盤子的代碼

package com.bankht.producerCustomer;

public class CriticalResources {
    private int index = 0;
    private static Fruits[] fruites = new Fruits[1];// 默認臨界區有五個商品
    private ProducerApple pa = new ProducerApple(this);
    private ProducerOrange po = new ProducerOrange(this);
    private ConsumerApple ca = new ConsumerApple(this);
    private ConsumerOrange co = new ConsumerOrange(this);

    /**
     * 向臨界資源裏添加商品 利用synchronized關鍵字實現同步 添加後數組指針+1
     * 若是臨界資源數組裏面裝滿了商品不能再生產，則生產線程等待以便讓消費者消費
     *
     * @param goods
     */
    public synchronized void push(Fruits goods) {
        //
        while (this.index == this.fruites.length) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        this.notifyAll();// 喚醒生產者
        this.fruites[index++] = goods;

    }

    /**
     * 從臨界資源裏拿商品，先減一後返回 若是index==0說明， 臨界資源數組裏面沒有商品，不能在消費 消費線程阻塞， 讓生產者生產 則讓生產者
     *
     * @return
     */
    public synchronized Fruits pop() {
        while (this.index == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        this.notifyAll();// 喚醒消費者
        return fruites[--index];

    }

    /**
     * 看看是否是空了
     *
     * @return
     */
    public synchronized Fruits peek() {
        if (this.index == 0)
            return null;
        else
            return fruites[index - 1];
    }

    public int getIndex() {
        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }

    public Fruits[] getFruites() {
        return fruites;
    }

}

下面是生產桔子和消費桔子的代碼

package com.bankht.producerCustomer;

public class ProducerOrange implements Runnable {
    CriticalResources cr = null;

    public ProducerOrange(CriticalResources cr) {
        super();
        this.cr = cr;
    }
    int count = 5; //作5次

    @Override
    public void run() {
         while(count-->0)
                synchronized (cr) {
                    while (cr.peek() != null) {
                        try {
                            cr.wait();// 該生產這等待
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                    Fruits fruits = new Orange("橘子");
                    cr.push(fruits);
                    System.out.println("橘子生產商生產了" + fruits);
                    cr.notifyAll();
                }

    }

}

 

package com.bankht.producerCustomer;

/**
 * 消費橘子的消費者
 *
 * @author Administrator
 *
 */
public class ConsumerOrange implements Runnable {

    private CriticalResources cr = null;// 封裝一個臨界資源對象，以便消費

    public ConsumerOrange(CriticalResources cr) {
        super();
        this.cr = cr;
    }

    int count = 5;

    @Override
    public void run() {

        while (count-- > 0)
            // 若是緩衝區是蘋果
            synchronized (cr) {
                while (!(cr.peek() instanceof Orange)) {
                    try {
                        cr.wait();// 該消費者等待
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                Fruits fruits = cr.pop();

                System.out.println("----橘子消費者消費了-------" + fruits);
                cr.notifyAll();
            }

    }

}

下面是生產蘋果核消費蘋果的代碼

package com.bankht.producerCustomer;


/**
 * 生產蘋果的生產者
 *
 * @author Arthur
 *
 */
public class ProducerApple implements Runnable {
    private CriticalResources cr = null;// 封裝一個臨界資源對象，以便生產

    public ProducerApple(CriticalResources cr) {
        super();
        this.cr = cr;
    }

    private int count = 5;

    @Override
    public void run() {
        while (count-- > 0)
            synchronized (cr) {
                while ((cr.peek() != null)) {
                    try {
                        cr.wait();// 緩衝區滿，該生產者等待
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //若是不加鎖，此處容易被打斷
                Fruits fruits = new Apple("蘋果");
                cr.push(fruits);
                System.out.println("蘋果生產商生產了" + fruits);
                cr.notifyAll();
            }

    }

}

 

package com.bankht.producerCustomer;

/**
 * 消費蘋果的消費者
 *
 * @author Arthur
 *
 */
public class ConsumerApple implements Runnable {
    private CriticalResources cr = null;// 封裝一個臨界資源對象，以便消費

    public ConsumerApple(CriticalResources cr) {
        super();
        this.cr = cr;
    }
int count = 5;
    @Override
    public void run() {
         while(count-->0)
                synchronized (cr) {
                    while (!(cr.peek() instanceof Apple) ) {
                        try {
                            cr.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    Fruits fruits = cr.pop();

                    System.out.println("----蘋果消費者消費了-------" + fruits);
                    cr.notifyAll();

                }


    }
}

客戶端代碼

package com.bankht.producerCustomer;

public class Client {

      /**
     * @param args
     */
    public static void main(String[] args) {
        CriticalResources cr = new CriticalResources();
        // 生產蘋果實例
        ProducerApple appleP = new ProducerApple(cr);
        // 消費蘋果實例
        ConsumerApple appleC = new ConsumerApple(cr);

        // 橘子生產者實例
        ProducerOrange orangeP = new ProducerOrange(cr);
        // 橘子消費者實例
        ConsumerOrange orangeC = new ConsumerOrange(cr);
        // 生產蘋果線程
        Thread pThread = new Thread(appleP);
        // 消費蘋果線程
        Thread cThread = new Thread(appleC);
        // 生產橘子線程
        Thread pt = new Thread(orangeP);
        // 消費橘子線程
        Thread ct = new Thread(orangeC);



        pThread.start();
        cThread.start();
        pt.start();
        ct.start();
    }

}

運行結果：

 

蘋果生產商生產了蘋果
----蘋果消費者消費了-------蘋果
橘子生產商生產了橘子
----橘子消費者消費了-------橘子
蘋果生產商生產了蘋果
----蘋果消費者消費了-------蘋果
橘子生產商生產了橘子
----橘子消費者消費了-------橘子
蘋果生產商生產了蘋果
----蘋果消費者消費了-------蘋果
橘子生產商生產了橘子
----橘子消費者消費了-------橘子
蘋果生產商生產了蘋果
----蘋果消費者消費了-------蘋果
橘子生產商生產了橘子
----橘子消費者消費了-------橘子
蘋果生產商生產了蘋果
----蘋果消費者消費了-------蘋果
橘子生產商生產了橘子
----橘子消費者消費了-------橘子