读前建议

如果需要对本文有更加深刻的了解建议了解一下线程安全、线程死锁、以及线程通信相关的知识，如果说您对这些已经有了足够的了解，相信你读完这篇博文一定收获颇丰！

一、情景设计

现有两个线程，线程的作用是将字符串’A’ ‘B’ ‘C’ ‘D’ ‘E’或’F’ ‘G’ ‘H’ ‘I’ 'J’存入容器Array List()中，但是为了保证线程的安全，每次只能让一个线程访问，因此每个线程必须获得临界资源对象即容器的锁标记才能访问该对象，进而进行数据存储操作；
但是，每个线程每次存入字符个数为五个，而容器只能存入四个字符串，当该线程的第五个字符串存入容器时，为防止程序异常，会使该线程进入无限期等待队列，并通知消费者进行取数据；
同样，消费者也有多个，也是获得锁标记的才有取数据的资格，这里假设有一个消费者consumer；消费者取数据时，假设每次取出一个，当将容器数据取完时，为保证线程安全，会使该线程进入无限期等待队列，并通知生产者进行数据存入；
在这里插入图片描述
整个流程就是java线程里生产者与消费者之间的设计模式；

二、引入生产者与消费者

首先需要清楚生产者与消费者的本质都是线程，若干个生产者在生产产品，这些产品将提供给若干个消费者取消费，为了使生产者和消费者能够并发执行，在两者之间设置一个能存储多个产品的缓冲区，生产者将生产的产品放入缓冲区中，消费者从缓冲区中取走产品进行消费，显然生产者和消费者之间必须保持同步，既不允许消费者到一个空的缓冲区中取走产品，也不允许生产者向一个满的缓冲区中放入产品。

三、情景的代码再现

首先，需要新建一个容器类Queue，容器的最大容量为4，类型是ArrayList类型，容器提供两个方法，一个是存入方法offer()，提供给生产者线程调用；另一个是取出方法poll()，提供给消费者线程调用；为满足生产者和消费者之间保持同步，每个方法必须做三件事情：

1.为保证线程安全，必须对容器加锁，即每次只能让持有锁标记的线程访问；此时方法需要用synchronized修饰；
2.当容器满或者空的时候（size == 0或size==4），对应的消费者线程或消费者线程进入无限期等待状态，调用wait()方法；
3.当容器不满或不为空，对应的消费者通知生产者生产添加，对应的生产者通知消费者消费取出；

在这里插入图片描述

数据缓存区域模拟

//我的队列
class MyQueue {

    private List values = new ArrayList();

    private int max = 4;

    //存入队列
    public synchronized void offer(Object o){//E

        while(values.size() == max){
            //进来线程，停下
            try {
                this.wait();
                //被唤醒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notifyAll();
		values.add(o);
        System.out.println(Thread.currentThread().getName() + "存入元素 : "+ values );
    }

    //从队列取出
    public synchronized Object poll(){//1个元素

        while(values.size() == 0){
            try {
                this.wait();
                //被唤醒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        this.notifyAll();//唤醒因mq对象而进入无限期等待的线程对象（一个）

        return values.remove(0);
    }
}

生产者模拟

生产者本质上就是一个线程，这里用到了两个生产者，即多线程访问，一个临界资源对象Queue，线程只有持有该对象的锁标记的时候才能访问该对象，进而进行相应的操作。

//生产者1
class Produce1 extends Thread{
    MyQueue mq;
    public Produce1(MyQueue mq){
        this.mq = mq;
    }

    public void run(){
        System.out.println("Produce1启动");
        for (char ch = 'A'; ch <= 'E'; ch++) {
            mq.offer(ch);
        }
        System.out.println("Produce1结束");
    }
}
//生产者2
class Produce2 extends Thread{
    MyQueue mq;
    public Produce2(MyQueue mq){
        this.mq = mq;
    }

    public void run(){
        System.out.println("Produce2启动");
        for (char ch = 'F'; ch <= 'J'; ch++) {
            mq.offer(ch);
        }
        System.out.println("Produce2结束");
    }
}

消费者模拟

消费者本质上也是一个线程，当然消费者也可以像生产者一样有多个，类似的，只有拥有锁标记的消费者线程才有权操作临界资源对象；这里为了方便，假设有一个消费者；

//消费者
class Consumer extends Thread{
    MyQueue mq;
    public Consumer(MyQueue mq){
        this.mq = mq;
    }

    public void run(){
        for (int i = 0 ; i < 10 ; i++) {//循环取数据
            System.out.println(mq.poll() + "被移除");
        }
    }
}

主函数

主函数就是让所有线程开始执行即可！

public static void main(String[] args) {

    MyQueue mq = new MyQueue();

    Produce1 p1 = new Produce1(mq);
    Produce2 p2 = new Produce2(mq);
    Consumer c1 = new Consumer(mq);

    p1.start();
    p2.start();
    c1.start();


    System.out.println("main end");
}