Java程序设计之消费者和生产者

　　新建一个Break类，表示食物数量。

public class Break {
    public static final int MAX = 10;  //最多一次性煮十个面包
    Stack<Integer> stack = new Stack<Integer>();
    public static int food_count = 0; //统计食物的个数
    
    //做面包
    public synchronized void make_food(int number){
        stack.push(number);
        food_count++;
    }
    
    //吃食物
    public synchronized int eat_food(){
        food_count--;
        return stack.pop();
    }
}

　　在创建一个厨房类，为了制作食物或者是消耗食物，若食物没有了，则消费者进入wait(),生产者开始制作食物，随后唤醒等待的消费者。

public class Kitchen {
    private Break food ;
    public static int people1_eatnumber = 0;//第一个人吃的面包数量
    public static int people2_eatnumber = 0;//第二个人吃的面包数量
    public static final int TOTOAL_NUM = 100;//总共做的面包数量
    public static int icount = 1;//统计做过的面包数量
    
    public Kitchen(Break food){
        this.food = food;
    }
    
    //做面包的方法
    public synchronized void make(){
        if(food.food_count<10){//锅是不是满了
            food.make_food(Kitchen.icount);
            System.out.println("做完了第"+Kitchen.icount+"个食物。");
            Kitchen.icount++;
            notifyAll();//食物有了，找两个人来吃面包
        }else{
            System.out.println("锅已经装满，一次性装十个，等待两人吃食物。");
            try {
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }//进入阻塞状态,等待消费者唤醒
        }
    }
    
    //吃面包的方法
    public synchronized void eat(){
        if(food.food_count>0){
            int temp = food.eat_food();//吃掉面包的编号
            System.out.println(Thread.currentThread().getName()+"吃掉了第"+temp+"个食物");
            if(Thread.currentThread().getName().equals("一号")){
                people1_eatnumber++;
            }else{
                people2_eatnumber++;
            }
            notifyAll();  //唤醒继续做面包
        }else{
            System.out.println("食物吃完了，等待重新烹饪。");
            try {
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

　　下面进入消费者和生产者类的构造，传递给一个Kitchen对象，其中消费者调用Kitchen类中的吃方法。

public class consumer implements Runnable {
    Kitchen kitchen;
    
    public consumer(Kitchen kitchen){
        this.kitchen = kitchen;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        while(true){
            if(kitchen.icount>100&&Break.food_count<=0){
                break;
            }
            try{
                kitchen.eat();
                Thread.sleep(100);
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

　　然而生产者则是调用了Kitchen对象中的制作方法。

public class product implements Runnable {
    private Kitchen kitchen;
    public product(Kitchen kitchen){
        this.kitchen = kitchen;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        while(true){
            //结束这个线程
            if(Kitchen.icount > 100){
                break;
            }
            try{                
                kitchen.make();
                Thread.sleep(100);
                }catch(Exception e){
                e.printStackTrace();
            }
        }
        System.out.println("厨房食物材料已经做完。");
    }
}

　　下面开始写主类，包括了main方法，启动程序，创建一个test类，实现：

public class test {
    public static void main(String[] args){
        Break brake = new Break();
        Kitchen kitchen = new Kitchen(brake);
        product p = new product(kitchen);
        consumer c1 = new consumer(kitchen);
        consumer c2 = new consumer(kitchen);
        
        Thread food = new Thread(p,"食物");
        Thread people1 = new Thread(c1,"一号");
        Thread people2 = new Thread(c2,"二号");
        
        food.start();
        people1.start();
        people2.start();
        
        try{
            food.join();
            people1.join();
            people2.join();
        }catch(Exception e){
            e.printStackTrace();
        }
        
        System.out.println("一号吃了"+Kitchen.people1_eatnumber);
        System.out.println("二号吃了"+Kitchen.people2_eatnumber);
    }
}

输出结果如下：

做完了第1个食物。
二号吃掉了第1个食物
食物吃完了，等待重新烹饪。
食物吃完了，等待重新烹饪。
做完了第2个食物。
一号吃掉了第2个食物
食物吃完了，等待重新烹饪。
做完了第3个食物。
一号吃掉了第3个食物
食物吃完了，等待重新烹饪。
做完了第4个食物。
一号吃掉了第4个食物
做完了第5个食物。
二号吃掉了第5个食物
食物吃完了，等待重新烹饪。
做完了第6个食物。
二号吃掉了第6个食物
食物吃完了，等待重新烹饪。
做完了第7个食物。
二号吃掉了第7个食物
做完了第8个食物。
一号吃掉了第8个食物
食物吃完了，等待重新烹饪。
食物吃完了，等待重新烹饪。
做完了第9个食物。
一号吃掉了第9个食物
食物吃完了，等待重新烹饪。
做完了第10个食物。
一号吃掉了第10个食物
做完了第11个食物。
二号吃掉了第11个食物
食物吃完了，等待重新烹饪。
做完了第12个食物。
二号吃掉了第12个食物
食物吃完了，等待重新烹饪。
食物吃完了，等待重新烹饪。
做完了第13个食物。
一号吃掉了第13个食物
做完了第14个食物。
二号吃掉了第14个食物
食物吃完了，等待重新烹饪。
食物吃完了，等待重新烹饪。
做完了第15个食物。
一号吃掉了第15个食物
做完了第16个食物。
二号吃掉了第16个食物
食物吃完了，等待重新烹饪。
做完了第17个食物。
二号吃掉了第17个食物
食物吃完了，等待重新烹饪。
做完了第18个食物。
二号吃掉了第18个食物
食物吃完了，等待重新烹饪。
做完了第19个食物。
二号吃掉了第19个食物
食物吃完了，等待重新烹饪。
做完了第20个食物。
二号吃掉了第20个食物
食物吃完了，等待重新烹饪。
做完了第21个食物。
二号吃掉了第21个食物
食物吃完了，等待重新烹饪。
做完了第22个食物。
二号吃掉了第22个食物
食物吃完了，等待重新烹饪。
做完了第23个食物。
二号吃掉了第23个食物
食物吃完了，等待重新烹饪。
做完了第24个食物。
二号吃掉了第24个食物
食物吃完了，等待重新烹饪。
做完了第25个食物。
二号吃掉了第25个食物
食物吃完了，等待重新烹饪。
做完了第26个食物。
二号吃掉了第26个食物
食物吃完了，等待重新烹饪。
食物吃完了，等待重新烹饪。
做完了第27个食物。
一号吃掉了第27个食物
食物吃完了，等待重新烹饪。
做完了第28个食物。
一号吃掉了第28个食物
食物吃完了，等待重新烹饪。
做完了第29个食物。
一号吃掉了第29个食物
做完了第30个食物。
二号吃掉了第30个食物
食物吃完了，等待重新烹饪。
做完了第31个食物。
二号吃掉了第31个食物
食物吃完了，等待重新烹饪。
食物吃完了，等待重新烹饪。
做完了第32个食物。
一号吃掉了第32个食物
食物吃完了，等待重新烹饪。
做完了第33个食物。
一号吃掉了第33个食物
食物吃完了，等待重新烹饪。
做完了第34个食物。
一号吃掉了第34个食物
做完了第35个食物。
二号吃掉了第35个食物
食物吃完了，等待重新烹饪。
做完了第36个食物。
二号吃掉了第36个食物
食物吃完了，等待重新烹饪。
食物吃完了，等待重新烹饪。
做完了第37个食物。
一号吃掉了第37个食物
食物吃完了，等待重新烹饪。
做完了第38个食物。
一号吃掉了第38个食物
食物吃完了，等待重新烹饪。
做完了第39个食物。
一号吃掉了第39个食物
做完了第40个食物。
二号吃掉了第40个食物
食物吃完了，等待重新烹饪。
食物吃完了，等待重新烹饪。
做完了第41个食物。
一号吃掉了第41个食物
做完了第42个食物。
二号吃掉了第42个食物
做完了第43个食物。
二号吃掉了第43个食物
食物吃完了，等待重新烹饪。
食物吃完了，等待重新烹饪。
做完了第44个食物。
一号吃掉了第44个食物
食物吃完了，等待重新烹饪。
做完了第45个食物。
一号吃掉了第45个食物
做完了第46个食物。
二号吃掉了第46个食物
食物吃完了，等待重新烹饪。
做完了第47个食物。
二号吃掉了第47个食物
食物吃完了，等待重新烹饪。
做完了第48个食物。
二号吃掉了第48个食物
食物吃完了，等待重新烹饪。
做完了第49个食物。
二号吃掉了第49个食物
食物吃完了，等待重新烹饪。
做完了第50个食物。
二号吃掉了第50个食物
食物吃完了，等待重新烹饪。
食物吃完了，等待重新烹饪。
做完了第51个食物。
一号吃掉了第51个食物
食物吃完了，等待重新烹饪。
做完了第52个食物。
一号吃掉了第52个食物
做完了第53个食物。
二号吃掉了第53个食物
做完了第54个食物。
一号吃掉了第54个食物
食物吃完了，等待重新烹饪。
食物吃完了，等待重新烹饪。
做完了第55个食物。
做完了第56个食物。
二号吃掉了第56个食物
一号吃掉了第55个食物
做完了第57个食物。
一号吃掉了第57个食物
食物吃完了，等待重新烹饪。
做完了第58个食物。
一号吃掉了第58个食物
做完了第59个食物。
二号吃掉了第59个食物
食物吃完了，等待重新烹饪。
食物吃完了，等待重新烹饪。
做完了第60个食物。
一号吃掉了第60个食物
做完了第61个食物。
二号吃掉了第61个食物
食物吃完了，等待重新烹饪。
做完了第62个食物。
二号吃掉了第62个食物
食物吃完了，等待重新烹饪。
做完了第63个食物。
二号吃掉了第63个食物
食物吃完了，等待重新烹饪。
做完了第64个食物。
二号吃掉了第64个食物
食物吃完了，等待重新烹饪。
做完了第65个食物。
二号吃掉了第65个食物
食物吃完了，等待重新烹饪。
食物吃完了，等待重新烹饪。
做完了第66个食物。
做完了第67个食物。
二号吃掉了第67个食物
一号吃掉了第66个食物
做完了第68个食物。
一号吃掉了第68个食物
食物吃完了，等待重新烹饪。
做完了第69个食物。
一号吃掉了第69个食物
食物吃完了，等待重新烹饪。
做完了第70个食物。
一号吃掉了第70个食物
做完了第71个食物。
二号吃掉了第71个食物
食物吃完了，等待重新烹饪。
做完了第72个食物。
二号吃掉了第72个食物
食物吃完了，等待重新烹饪。
做完了第73个食物。
二号吃掉了第73个食物
食物吃完了，等待重新烹饪。
食物吃完了，等待重新烹饪。
做完了第74个食物。
一号吃掉了第74个食物
食物吃完了，等待重新烹饪。
做完了第75个食物。
一号吃掉了第75个食物
做完了第76个食物。
二号吃掉了第76个食物
食物吃完了，等待重新烹饪。
做完了第77个食物。
二号吃掉了第77个食物
食物吃完了，等待重新烹饪。
做完了第78个食物。
二号吃掉了第78个食物
食物吃完了，等待重新烹饪。
做完了第79个食物。
二号吃掉了第79个食物
食物吃完了，等待重新烹饪。
做完了第80个食物。
二号吃掉了第80个食物
食物吃完了，等待重新烹饪。
做完了第81个食物。
二号吃掉了第81个食物
食物吃完了，等待重新烹饪。
做完了第82个食物。
二号吃掉了第82个食物
食物吃完了，等待重新烹饪。
做完了第83个食物。
二号吃掉了第83个食物
食物吃完了，等待重新烹饪。
做完了第84个食物。
二号吃掉了第84个食物
食物吃完了，等待重新烹饪。
做完了第85个食物。
二号吃掉了第85个食物
食物吃完了，等待重新烹饪。
做完了第86个食物。
二号吃掉了第86个食物
食物吃完了，等待重新烹饪。
做完了第87个食物。
二号吃掉了第87个食物
食物吃完了，等待重新烹饪。
做完了第88个食物。
二号吃掉了第88个食物
做完了第89个食物。
二号吃掉了第89个食物
食物吃完了，等待重新烹饪。
做完了第90个食物。
二号吃掉了第90个食物
食物吃完了，等待重新烹饪。
做完了第91个食物。
二号吃掉了第91个食物
食物吃完了，等待重新烹饪。
做完了第92个食物。
二号吃掉了第92个食物
食物吃完了，等待重新烹饪。
做完了第93个食物。
二号吃掉了第93个食物
食物吃完了，等待重新烹饪。
做完了第94个食物。
二号吃掉了第94个食物
食物吃完了，等待重新烹饪。
做完了第95个食物。
二号吃掉了第95个食物
食物吃完了，等待重新烹饪。
做完了第96个食物。
二号吃掉了第96个食物
食物吃完了，等待重新烹饪。
做完了第97个食物。
二号吃掉了第97个食物
食物吃完了，等待重新烹饪。
做完了第98个食物。
二号吃掉了第98个食物
食物吃完了，等待重新烹饪。
做完了第99个食物。
二号吃掉了第99个食物
食物吃完了，等待重新烹饪。
做完了第100个食物。
二号吃掉了第100个食物
厨房食物材料已经做完。
一号吃了33
二号吃了67