生产者消费者问题

方法一：
第一步：我们先创建共享资源的类 Person,它有两个方法，一个生产对象，一个消费对象

public class Person {
    private String name;
    private int age;
     
    //表示共享资源对象是否为空，如果为 true，表示需要生产，如果为 false，则有数据了，不要生产
    private boolean isEmpty = true;
    /**
     * 生产数据
     * @param name
     * @param age
     */
    public synchronized void push(String name,int age){
        try {
            //不能用 if，因为可能有多个线程
            while(!isEmpty){//进入到while语句内，说明 isEmpty==false，那么表示有数据了，不能生产，必须要等待消费者消费
                this.wait();//导致当前线程等待，进入等待池中，只能被其他线程唤醒
            }
             
            //-------生产数据开始-------
            this.name = name;
            //延时代码
            Thread.sleep(10);
            this.age = age;
            //-------生产数据结束-------
            isEmpty = false;//设置 isEmpty 为 false,表示已经有数据了
            this.notifyAll();//生产完毕，唤醒所有消费者
        } catch (Exception e) {
            e.printStackTrace();
        }
         
    }
    /**
     * 取数据，消费数据
     * @return
     */
    public synchronized void pop(){
        try {
            //不能用 if，因为可能有多个线程
            while(isEmpty){//进入 while 代码块，表示 isEmpty==true,表示为空，等待生产者生产数据，消费者要进入等待池中
                this.wait();//消费者线程等待
            }
            //-------消费开始-------
            Thread.sleep(10);
            System.out.println(this.name+"---"+this.age);
            //-------消费结束------
            isEmpty = true;//设置 isEmpty为true，表示需要生产者生产对象
            this.notifyAll();//消费完毕，唤醒所有生产者
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

第二步：创建生产者线程，并在 run() 方法中生产50个对象

public class Producer implements Runnable{
    //共享资源对象
    Person p = null;
    public Producer(Person p){
        this.p = p;
    }
    @Override
    public void run() {
        //生产对象
        for(int i = 0 ; i < 50 ; i++){
            //如果是偶数，那么生产对象 Tom--11;如果是奇数，则生产对象 Marry--21
            if(i%2==0){
                p.push("Tom", 11);
            }else{
                p.push("Marry", 21);
            }
        }
    }
}

第三步：创建消费者线程，并在 run() 方法中消费50个对象

public class Consumer implements Runnable{
    //共享资源对象
    Person p = null;
    public Consumer(Person p) {
        this.p = p;
    }
     
    @Override
    public void run() {
        for(int i = 0 ; i < 50 ; i++){
            //消费对象
            p.pop();
        }
    }
}

第四步：创建main方法

public static void main(String[] args) {
    Person person = new Person();
    Producer producer = new Producer(person);
    Consumer consumer = new Consumer(person);
    Thread t1=new Thread(producer);
    Thread t2=new Thread(consumer);
    t1.start();
    t2.start();
}

效果图：

方法二：

//店员
public class Clerk{

    //产品
    int product;

    //生产产品
    public synchronized void addProduct(){
        if(product >=20){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else {
            product++;
            System.out.println(Thread.currentThread().getName() + ":生产了第" + product + "个产品");
            notifyAll();
        }
    }
    //消费产品
    public synchronized void consumeProduct(){
        if(product <= 0){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else{
            System.out.println(Thread.currentThread().getName() + ":消费了第" + product + "个产品");
            product--;
            notifyAll();
        }
    }
}

//消费者
class Consumer2 implements Runnable{
    Clerk clerk;
    public Consumer2(Clerk clerk){
        this.clerk = clerk;
    }
    @Override
    public void run() {
        System.out.println("消费者消费产品");
        while(true){
            try {
                Thread.currentThread().sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumeProduct();
        }
    }
}

//生产者
class Producer2 implements Runnable{

    Clerk clerk;
    //设置一个构造器，将Clerk传入
    public Producer2(Clerk clerk){
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println("生产者开始生产产品");
        while(true){
            try {
                Thread.currentThread().sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.addProduct();
        }
    }
}

public static void main(String[] args) {

    Clerk clerk = new Clerk();
    Producer2 p1 = new Producer2(clerk);
    Consumer2 c1 = new Consumer2(clerk);
    Thread t1 = new Thread(p1);//一个生产者的线程
    Thread t2 = new Thread(c1);//一个消费者的线程
    t1.setName("生产者1");
    t2.setName("消费者1");
    t1.start();
    t2.start();
}

运行结果：

多生产者、多消费者情况：

public static void main(String[] args) {

    Clerk clerk = new Clerk();
    Producer2 p1 = new Producer2(clerk);
    Consumer2 c1 = new Consumer2(clerk);

    Thread t1 = new Thread(p1);//一个生产者的线程
    Thread t2 = new Thread(c1);//一个消费者的线程

    Producer2 p3 = new Producer2(clerk);
    Consumer2 c4 = new Consumer2(clerk);

    Thread t3 = new Thread(p3);//一个生产者的线程
    Thread t4 = new Thread(c4);//一个消费者的线程

    t1.setName("生产者1");
    t2.setName("消费者1");

    t3.setName("生产者2");
    t4.setName("消费者2");
    
    t1.start();
    t2.start();
    t3.start();
    t4.start();
}

运行结果：