线程学习例题：生产者消费者案例

生产者消费者案例中包含的类：

• 奶箱类(Box):定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作

package AA_基于线程的生产者消费者案例;
​
//定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作
public class Box {
    private int milk;
    //定义一个成员变量，表示奶箱的状态
    private boolean state = false;
​
    //提供存储牛奶和获取牛奶的操作
    //存牛奶的方法
    public synchronized void put(int milk) {
        //当奶箱里面有牛奶的时候需要等待消费者消费
        if(state){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //当没有牛奶时添加牛奶
        this.milk = milk;
        System.out.println("送奶工将" + this.milk + "瓶奶放入奶箱");
        //这时奶箱中有牛奶，则需要修改奶箱状态
        state=true;
​
        //需要唤醒其他线程
        notifyAll();
    }
​
    //获取牛奶的方法
    public synchronized void get() {
        当奶箱里面没有牛奶的时候需要等待送奶工添加牛奶
        if(!state){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //当奶箱里面有牛奶的时候，消费者需要拿奶
        System.out.println("消费者将第" + this.milk + "瓶奶拿走");
​
        //这时奶箱中没有奶，则需要修改奶箱状态
        state=false;
​
        //需要唤醒其他线程
        notifyAll();
    }
}

​

• 生产者类(Producer):实现Runnable接口，重写run()方法，调用存储牛奶的操作

package AA_基于线程的生产者消费者案例;
​
//生产者类(Producer):实现Runnable接口，重写run()方法，调用存储牛奶的操作
public class Producer implements Runnable {
    private Box box;
​
    public Producer(Box box) {
        this.box = box;
    }
​
    @Override
    public void run() {
        //调用存储牛奶的操作
        for (int i = 1; i <= 5; i++) {
            box.put(i);
        }
    }
}
​

• 消费者类(Customer):实现Runnable接口，重写run()方法，调用获取牛奶的操作

package AA_基于线程的生产者消费者案例;
​
public class Customer implements Runnable {
    private Box box;
​
    public Customer(Box box) {
        this.box = box;
    }
​
    @Override
    public void run() {
        while (true) {
            box.get();
        }
    }
}

• 测试类(BoxDemo):里面有main方法，main方法中的代码步骤如下

  • 创建奶箱对象，这是共享数据区域

  • 创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作

  • 创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作

  • 创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递

  • 启动线程

package AA_基于线程的生产者消费者案例;
​
/**
 * 生产者消费者案例中包含的类：
 *      奶箱类(Box):定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作
 *      生产者类(Producer):实现Runnable接口，重写run()方法，调用存储牛奶的操作
 *      消费者类(Customer):实现Runnable接口，重写run()方法，调用获取牛奶的操作
 *      测试类(BoxDemo):里面有main方法，main方法中的代码步骤如下:
 *              1、创建奶箱对象，这是共享数据区域
 *              2、创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
 *              3、创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
 *              4、创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
 *              5、启动线程
 */
public class BoxDemo {
    public static void main(String[] args) {
        //创建奶箱对象，这是共享数据区域
        Box box = new Box();
​
        //生产者类(Producer):实现Runnable接口，重写run()方法，调用存储牛奶的操作
        Producer p = new Producer(box);
​
        //消费者类(Customer):实现Runnable接口，重写run()方法，调用获取牛奶的操作
        Customer c = new Customer(box);
​
        //创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);
​
        //启动线程
        t1.start();
        t2.start();
    }
}
​