Java微服务架构师_Java 并发编程_003

生产者-消费者模式是一个十分经典的多线程并发协作的模式，弄懂生产者-消费者问题能够让我们对并发编程的理解加深。这也是多线程编程的主要业务应用场景。
所谓生产者-消费者问题，实际上主要是包含了两类线程，一种是生产者线程用于生产数据，另一种是消费者线程用于消费数据，为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库，生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为；而消费者只需要从共享数据区中去获取数据，就不再需要关心生产者的行为。但是，这个共享数据区域中应该具备这样的线程间并发协作的功能：

如果共享数据区已满的话，阻塞生产者继续生产数据放置入内；
如果共享数据区为空的话，阻塞消费者继续消费数据；

下面通过代码演示：

在实现生产者消费者问题时，可以采用三种方式：

1.使用Object的wait/notify配合synchronized同步锁的消息通知机制；

2.使用Lock的Condition的await/signal的消息通知机制；

3.使用BlockingQueue实现。

由于后面2种刚开始学习并发编程使用不到，我们先从第一种方式来了解这个模式。

package com.allen.base.day02;

import java.util.concurrent.ArrayBlockingQueue;

public class ProducerConsumerModel {
    private static final int MAX_SIZE = 10;
    ArrayBlockingQueue queue = new ArrayBlockingQueue(10);


    public static void main(String[] args) {
        ProducerConsumerModel model = new ProducerConsumerModel();

        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        String product = "生产=>元素" + System.currentTimeMillis() % 100;
                        model.put(product);
                        Thread.sleep(20);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while (true) {
                        model.take();
                        Thread.sleep(1000);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        threadA.start();
        threadB.start();

    }

    public void put(String ele) throws InterruptedException {
        synchronized (queue) {
            while (queue.size() == MAX_SIZE) {
                System.out.println("队列满了=====================>{" + queue.size() + "}");
                queue.wait();
            }
            System.out.println("ele: "+ele);
            queue.put(ele);
            queue.notify();
        }
    }

    public void take() throws InterruptedException {
        synchronized (queue) {
            while (queue.size() == 0) {
                System.out.println("队列空了");
                queue.wait();
            }
            String take = (String) queue.take();
            System.out.println("消费了" + take);
            queue.notify();
        }
    }
}

生产者不断生产元素，满了后就被阻塞挂起，直到消费者消费后有空闲空间，才会继续添加新的元素：

ele: 生产=>元素15
消费了生产=>元素15
ele: 生产=>元素36
ele: 生产=>元素56
ele: 生产=>元素76
ele: 生产=>元素96
ele: 生产=>元素16
ele: 生产=>元素36
ele: 生产=>元素56
ele: 生产=>元素76
ele: 生产=>元素96
ele: 生产=>元素16
队列满了=====================>{10}
消费了生产=>元素36
ele: 生产=>元素36
队列满了=====================>{10}
消费了生产=>元素56
ele: 生产=>元素36
队列满了=====================>{10}