java解决生产者与消费者的问题

思路分析

• 当缓冲区（即仓库）已满时，生产者线程停止执行，放弃锁，使自己处于等待状态，让其他线程执行
• 当缓冲区已空时，消费者线程停止执行，放弃锁，让其他线程执行
• 当生产者向缓冲区放入一个产品时，向其他线程发出可执行的通知（唤醒其他线程），同时放弃锁，使自己处于等待状态
• 当消费者从缓冲区中取出一个产品时，唤醒其他线程，放弃锁，使自己处于等待状态

代码实现

首先创建一个仓库类:包含生产和消费方法

/*首先创建一个仓库类*/
 public  class Warehouse {
    /*定义仓库容量*/
    private final int maxsize=10;
    /*创建仓库的载体*/
    private LinkedList<Object> list=new LinkedList<>();
    /*写一个生产产品的方法*/
    public void produce(){
        synchronized (list){
            while(list.size()>=maxsize){
                System.out.println("生产者"+Thread.currentThread().getName()+"仓库已满");
                try {
                    //释放当前锁
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            /*生产一个产品*/
            list.add(new Object());
            System.out.println("生产者"+Thread.currentThread().getName()+
                    "生产了一个产品，现库存"+list.size());
            // 向其他等待的线程发出可执行的通知
            list.notifyAll();
        }
    }
    /*写一个消费产品的方法*/
    public void consume(){
        synchronized (list){
            while (list.size()==0){
                System.out.println("消费者"+Thread.currentThread().getName()
                +"仓库为空");
                try {
                    //让消费者线程等待
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            /*消费一个产品*/
            list.remove();
            System.out.println("消费者"+Thread.currentThread().getName()+
                    "消费一个产品，现库存"+list.size());
            /*唤醒其他线程*/
            list.notifyAll();
        }
    }
}

然后创建一个生产者和消费者类

/*创建一个生产者类*/
class Producer implements Runnable{
  private Warehouse warehouse;//创建一个生产者对象

    public Producer(Warehouse warehouse) {
        this.warehouse = warehouse;
    }
    public Producer(){

}
    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(1000);
                warehouse.produce();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
/*创建一个消费者类*/
class Consumer implements Runnable{
   private Warehouse warehouse;

    public Consumer(Warehouse warehouse) {
        this.warehouse = warehouse;
    }

    public Consumer() {
    }

    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(3000);
                warehouse.consume();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

最后测试

class Test1{
    public static void main(String[] args) {
        Warehouse warehouse=new Warehouse();
        Thread p1=new Thread(new Producer(warehouse));
        Thread p2=new Thread(new Producer(warehouse));
        Thread p3=new Thread(new Producer(warehouse));
        Thread c1=new Thread(new Consumer(warehouse));
        Thread c2=new Thread(new Consumer(warehouse));
        Thread c3=new Thread(new Consumer(warehouse));
        p1.start();
        p2.start();
        p3.start();
        c1.start();
        c2.start();
        c3.start();

    }
}

这是结果