多线程生产者消费者实例

• 目的

        生产者和消费者实例主要是练习synchronized、wait、notify或notifyAll、join等的使用，实际感受他们的用途。这例子自己随意写的，也没想到写得多么完善，只是为了练习。大家将就看看吧，哈哈！

---

• 食物类

package thread.producer.customer;

public class Food {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    
}

• 盘子类

package thread.producer.customer;


public class Plate {

    //如果是0，表示盘子内没东西
    private int index;
    private volatile boolean foodIsFinish = false;
    
    /**
     * 向盘子内添加食物,生产者添加食物时,消费者是不能吃食物的,小心被烫到,哈哈
     * @param food
     */
    public synchronized void addFood(Food food) {
        index++;
        System.out.println("盘子内增加了" + food.getName());
        notifyAll();
    }
    
    public synchronized void eatFood(String chihuo) throws InterruptedException{
        //盘子中没有食物,不代表生产者已经将食物生产完,所以此处要判断生产者是否将食物生产完
        //只有在盘子没有食物,同时生产者生产完所有食物的时候,该线程才什么都不做,直到线程结束
        while(index == 0 && !foodIsFinish) {
//            System.out.println(chihuo + "在等待食物");
            wait();
        }
        if(index > 0) {
            index--;
            System.out.println("盘子内被"+chihuo+"吃掉");
        }
    }
    
    public synchronized boolean isEmpty() {
        return index == 0;
    }
    
    public synchronized void setFoodIsFinish(){
        this.foodIsFinish = true;
    }
    
    public synchronized boolean getFoodIsFinish() {
        return foodIsFinish;
    }
    /**
     * 等待生产者线程执行完毕,该方法不能为同步方法
     * @param threads
     * @throws InterruptedException
     */
    public void waitProducerFinish(Thread producerThread) throws InterruptedException {
        producerThread.join();
        System.out.println("生产者生产食物完毕");
        //每个线程结束后,唤醒其他线程,因为有可能出现生产者线程执行完毕,而消费者线程在等待状态,这样就会出现消费者线程一直处于等待状态
        //这里只能用同步代码块，不能将整个方法进行同步
        synchronized(this) {
            setFoodIsFinish();
            //notify,notifyAll方法必须在同步方法或同步代码块内,wait方法也一样
            notifyAll();
        }
    }
    
    /**
     * 该方法不能为同步方法
     * @param threads
     * @throws InterruptedException
     */
    public void waitCustomerFinish(Thread[] threads) throws InterruptedException {
        for(int i = 0; i < threads.length; i++) {
            threads[i].join();
        }
        System.out.println("消费者线程结束");
    }
}

• 消费者线程

package thread.producer.customer;

public class CustomerThread implements Runnable{
    
    private Plate plate;
    private String chihuo;
    
    public CustomerThread(Plate plate, String chihuo) {
        this.plate = plate;
        this.chihuo = chihuo;
    }

    @Override
    public void run() {
        try {
            //判断盘子是否为空以及生产者是否已经生产食物完毕
            //只要在盘子为空或者生产者还有食物生产时,才不跳出循环
            //这样判断是防止生产者还有食物生产,恰好盘子中无食物,线程退出的不正确情况出现
            while(!plate.isEmpty() || !plate.getFoodIsFinish()) {
//                System.out.println(chihuo + "准备吃食物");
                plate.eatFood(chihuo);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

• 生产者线程

 

package thread.producer.customer;

public class ProducerThread implements Runnable{
    
    private Plate plate;
    
    public ProducerThread(Plate plate){
        this.plate = plate;
    }

    @Override
    public void run() {
        String[] foodType = {"apple","banana","pear","plum","grape","drumstick","hamburg","pineapple","staswberry","orange"};
        for(int i = 0; i < 100; i++) {
            int random = (int) (Math.random() * 10);
            Food food = new Food();
            food.setName(foodType[random]);
//            System.out.println("生产者准备添加食物");
            plate.addFood(food);
        }
    }
}

 

• 测试类

package thread.producer.customer;

public class Test {

    public static void main(String[] args) {
        Plate plate = new Plate();
        Thread t1 = new Thread(new ProducerThread(plate));
        Thread t2 = new Thread(new CustomerThread(plate, "吃货1号"));
        Thread t3 = new Thread(new CustomerThread(plate, "吃货2号"));
        t1.start();
        t2.start();
        t3.start();
        Thread[] threads = new Thread[2];
        threads[0] = t2;
        threads[1] = t3;
        try {
            plate.waitProducerFinish(t1);
            plate.waitCustomerFinish(threads);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}