java并发学习-异步模式-生产者/消费者

基本原理

该模式主要用来平衡生产和消费线程资源，具体的原理如下图所示：

1.生产者只负责生产消息，并将生产的消息添加至消息队列；

2.消费者只负责从消息队列中获取消息；

3.当队列的容量超过设定值时，生产线程进入等待；

4.当消息队列为空时，消费者线程进入等待。

代码实现

package com.java.pattern;

import lombok.Getter;
import lombok.extern.slf4j.Slf4j;

import java.util.LinkedList;

public class ProducerAndConsumer {
    public static void main(String[] args) {
        MessageQuque messageQuque = new MessageQuque(2);

        // 模拟生产者生产消息
        for (int i = 0; i < 3; i++) {
            int id = i;
            new Thread(() -> {
                messageQuque.put(new Message(id, "消息" + id));
            }, "producer" + i).start();
        }

        // 模拟消费者消费消息
        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                messageQuque.take();
            }, "consumer" + i).start();
        }
    }
}

/**
 * 消息队列
 */
@Slf4j(topic = "MessageQuque")
class MessageQuque {

    // 容器，用于存储消息
    private LinkedList<Message> messageList = new LinkedList<>();

    // 容器容量
    private int capacity;

    /**
     * 构造方法
     * @param capacity 容器容量
     */
    public MessageQuque(int capacity) {
        this.capacity = capacity;
    }

    /**
     * 获取消息
     * @return 消息
     */
    public Message take() {
        synchronized (this) {
            // 如果消息队列为空，消费者线程在此等待
            while (messageList.isEmpty()) {
                try {
                    log.debug("消息队列为空，消费者线程在此等待");
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 获取消息
            Message message = messageList.removeFirst();
            log.debug("消费者线程获取到消息：{}", message);
            // 叫醒等候的线程
            this.notifyAll();
            return message;
        }
    }

    /**
     * 向消息队列里添加消息
     * @param message 消息
     */
    public void put(Message message) {
        synchronized (this) {
            // 如果消息队列容量已到达设定值，生产者线程在此等待
            while (messageList.size() == capacity) {
                try {
                    log.debug("消息队列容量已到达设定值，生产者线程在此等待");
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 添加消息
            messageList.addLast(message);
            log.debug("生产者生产消息 ： {}", message);
            // 叫醒等候的线程
            this.notifyAll();
        }
    }
}

/**
 * 消息
 */
final class Message {
    // 消息id
    @Getter
    private int id;

    // 消息具体内容
    @Getter
    private String content;

    /**
     * 构造方法
     * @param id 消息id
     * @param content 消息具体内容
     */
    public Message(int id, String content) {
        this.id = id;
        this.content = content;
    }

    @Override
    public String toString() {
        return "Message{" +
                "id=" + id +
                ", content='" + content + '\'' +
                '}';
    }
}

执行结果：

18:43:47.187 [producer0] DEBUG MessageQuque - 生产者生产消息 ： Message{id=0, content='消息0'}
18:43:47.191 [consumer1] DEBUG MessageQuque - 消费者线程获取到消息：Message{id=0, content='消息0'}
18:43:47.191 [consumer0] DEBUG MessageQuque - 消息队列为空，消费者线程在此等待
18:43:47.192 [producer2] DEBUG MessageQuque - 生产者生产消息 ： Message{id=2, content='消息2'}
18:43:47.192 [producer1] DEBUG MessageQuque - 生产者生产消息 ： Message{id=1, content='消息1'}
18:43:47.192 [consumer0] DEBUG MessageQuque - 消费者线程获取到消息：Message{id=2, content='消息2'}