消费者、生产者、消息队列 实践一

Java Object的wait()、notify、notifyAll()：https://blog.csdn.net/haoranhaoshi/article/details/108528340 

消息队列可用于服务限流。服务请求数量达到阈值，进行处理等待。

消费者：

public class Consumer implements Runnable {
    private Queue<String> messageQueue;

    public Consumer(Queue<String> messageQueue) {
        this.messageQueue = messageQueue;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (messageQueue) {
                while (messageQueue.isEmpty()) {
                    // 如果消息队列为空了
                    try {
                        messageQueue.wait(); // 阻塞当前线程
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println("消费者消费：" + messageQueue.remove());
                messageQueue.notify(); //唤醒处于阻塞状态下的生产者线程
            }
        }
    }
}

生产者：

public class Product implements Runnable {
    private Queue<String> msg;
    private int maxSize;

    public Product(Queue<String> msg, int maxSize) {
        this.msg = msg;
        this.maxSize = maxSize;
    }

    @Override
    public void run() {
        int i = 0;
        while (true) {
            i++;
            synchronized (msg) { //同一把锁.
                while (msg.size() == maxSize) {
                    // 如果生产满了
                    try {
                        msg.wait(); // 阻塞当前线程
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println("生产者生产：消息" + i);
                msg.add("消息" + i);
                msg.notify(); //唤醒处于阻塞状态下的消费者线程
            }
        }
    }
}

测试： 

public class Test {
    public static void main(String[] args) {
        Queue<String> queue=new LinkedList<>();
        int maxSize=5;
        Product product=new Product(queue,maxSize);
        Consumer consumer=new Consumer(queue);
        Thread productThread=new Thread(product, "productThread");
        Thread consumerThread=new Thread(consumer, "consumerThread");
        productThread.start();
        consumerThread.start();
    }
}

结果：

生产者生产：消息1
生产者生产：消息2
生产者生产：消息3
生产者生产：消息4
生产者生产：消息5
消费者消费：消息1
生产者生产：消息6
消费者消费：消息2
消费者消费：消息3
消费者消费：消息4
消费者消费：消息5
消费者消费：消息6
生产者生产：消息7
生产者生产：消息8
生产者生产：消息9
生产者生产：消息10
...