编码实现生产者消费者模式

水深无声 2022-05-25 13:56 146阅读 0赞

# 编码实现生产者消费者模式 #

## 概念 ##

生产者和消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者之间不直接通信，而是通过阻塞队列来进行通信，所以生产者生产生产完数据之后不用等到消费者处理，直接扔给阻塞队列，消费者也不找生产者拿数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力  
这个阻塞队列就用来给生产者和消费者解耦的。

## 通过BlockingQueue来实现生产者消费者 ##

### 新建生产者类：Producer ###

import java.util.concurrent.BlockingQueue;
    
    /** * 生产者 * @author shanglishuai * */
    public class Producer implements Runnable { 
    
        private BlockingQueue<Object> blockingQueue;
    
        public Producer(BlockingQueue<Object> blockingQueue) {
            this.blockingQueue = blockingQueue;
        }
    
        int i = 0;
    
        @Override
        public void run() {
            while (true) {
                try {
                    System.out.println("生产者生产数据：" + i);
                    blockingQueue.put(i);
                    i ++;
                    // 休眠1秒钟，模拟业务场景
                    Thread.sleep(1000);
    
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
    }

### 新建消费者类：Consumer ###

import java.util.concurrent.BlockingQueue;
    
    /** * 消费者 * @author shanglishuai * */
    public class Consumer implements Runnable { 
    
        private BlockingQueue<Object> blockintQueue;
    
        public Consumer(BlockingQueue<Object> blockintQueue) {
            this.blockintQueue = blockintQueue;
        }
    
        @Override
        public void run() {
            while (true) {
                try {
                    System.out.println("消费者消费数据: " + blockintQueue.take());
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
    }

### 新建测试类：Test ###

import java.util.concurrent.BlockingQueue;
    import java.util.concurrent.LinkedBlockingQueue;
    
    public class Test { 
        public static void main(String[] args) {
            BlockingQueue<Object> blockingQueue = new LinkedBlockingQueue<Object>();
    
            Producer producer = new Producer(blockingQueue);
            Consumer consumer = new Consumer(blockingQueue);
    
            Thread tp = new Thread(producer);
            Thread tc = new Thread(consumer);
    
            tp.start();
            tc.start();
    
        }
    }

### 测试截图 ###

![这里写图片描述][70]

源代码链接：[https://github.com/myNameIssls/javase-study/tree/master/javase-multithreading/src/main/java/cn/tyrone/javase/producerconsumer][https_github.com_myNameIssls_javase-study_tree_master_javase-multithreading_src_main_java_cn_tyrone_javase_producerconsumer]

[70]: /images/20220525/b7301b8c3bbb4de781e92fe24b651696.png
[https_github.com_myNameIssls_javase-study_tree_master_javase-multithreading_src_main_java_cn_tyrone_javase_producerconsumer]: https://github.com/myNameIssls/javase-study/tree/master/javase-multithreading/src/main/java/cn/tyrone/javase/producerconsumer