java使用阻塞队列实现多生产者多消费者

最新推荐文章于 2023-03-25 14:26:01 发布

安世丶

最新推荐文章于 2023-03-25 14:26:01 发布

阅读量607

点赞数 1

分类专栏： Java基础

本文链接：https://blog.csdn.net/qq_36641571/article/details/108461243

版权

Java基础专栏收录该内容

3 篇文章 0 订阅

订阅专栏

实体类

package com.ssw.demo.MultThreadTest.ProducerAndConsumer;

/** 产品信息实体类
 * @author ssw
 * @created 2020/9/7 15:04
 * @since 1.0
 */
public class Product {

    private Integer id;
    private String name;
    private String ProducerName;

    public Product(Integer id, String name, String producerName) {
        this.id = id;
        this.name = name;
        ProducerName = producerName;
    }

    public Product(String name, String producerName) {
        this.name = name;
        ProducerName = producerName;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getProducerName() {
        return ProducerName;
    }

    public void setProducerName(String producerName) {
        ProducerName = producerName;
    }
}

中间仓库（使用阻塞队列BlockQueue）

package com.ssw.demo.MultThreadTest.ProducerAndConsumer;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * @author ssw
 * @created 2020/9/7 15:05
 * @since 1.0
 */
public class Storage {

    // 阻塞队列
    private BlockingQueue<Product> storage;
    private Integer productId; // 产品id

    public Storage(BlockingQueue<Product> storage, Integer productId) {
        this.storage = storage;
        this.productId = productId;
    }

    /**
     * 消费(从阻塞队列中取数据)
     */
    protected void pop(String consumerName) throws InterruptedException {
        if (storage.size() > 0) {
            Product p = storage.take();
            System.out.println(p.getName() + "的" + p.getProducerName() +
                    "--> id:" + p.getId() + "被" + consumerName + "消费了");
        }


    }

    /**
     * 生产（将数据存入阻塞队列）
     */
    protected void push(Product pro) throws InterruptedException {
        storage.put(pro);
//        this.notifyAll();
        pro.setId(productId++);
        System.out.println(pro.getName() + "生产了" + pro.getProducerName() +
                "--> id: " + pro.getId());
    }
}

启动类

package com.ssw.demo.MultThreadTest.ProducerAndConsumer;

import java.util.concurrent.*;

/** 多消费者和多生产者模式（）  参考https://blog.csdn.net/oumuv/article/details/87074062
 *
 * 最初设想：生产者启动多个线程执行任务，将任务执行结果抽取到队列中，消费者启动多个线程处理结果
 * 需要的api: ThreadPoolExecutor
 *
 * @author ssw
 * @created 2020/9/4 11:10
 * @since 1.0
 */
public class SingleProAndMultCon {

    private volatile Integer index=1;  // 多个消费者线程会对index进行++操作，加锁
    /**
     * 生产者线程
     */
    private class Producer implements Runnable {
        private String name;
        private String productName;
        private Storage storage;

        private Producer(String name, String productName, Storage storage) {
            this.name = name;
            this.productName = productName;
            this.storage = storage;
        }

        @Override
        public void run() {
            for (int i = 0; i < 15; i++) {

                Product p = new Product(name, productName);
                try {
                    storage.push(p);
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 消费者线程
     */
    private class Consumer implements Runnable {
        private Storage storage;
        private String consumerName;

        private Consumer(Storage storage, String consumerName) {
            this.storage = storage;
            this.consumerName = consumerName;
        }

        @Override
        public void run() {
            while (true) {
                try {
                    storage.pop(consumerName);
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        SingleProAndMultCon spac = new SingleProAndMultCon();
        Storage storage = new Storage(new LinkedBlockingQueue<>(), spac.index);
        Producer p1 = spac.new Producer("生产者1", "小米手机", storage);
        Producer p2 = spac.new Producer("生产者2", "华为手机", storage);
        Consumer c1 = spac.new Consumer(storage, "消费者1");
        Consumer c2 = spac.new Consumer(storage, "消费者2");
        int corePoolSize = Runtime.getRuntime().availableProcessors() * 2;  // 处理器数量*2
        ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, corePoolSize, 101, TimeUnit.SECONDS
                , new LinkedBlockingQueue<>(200));
        executor.submit(p1);
        executor.submit(p2);
        executor.submit(c1);
        executor.submit(c2);

        // 第一种
//        ExecutorService service = Executors.newCachedThreadPool();
//        service.submit(p1);
//        service.submit(p2);
//        service.submit(c1);


        // 第二种
//        int corePoolSize = Runtime.getRuntime().availableProcessors() * 2;  // 处理器数量*2
//        ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, corePoolSize, 101, TimeUnit.SECONDS
//                , new LinkedBlockingQueue<>(200));
//        executor.submit(p1);
//        executor.submit(p2);
//        executor.submit(c1);
        executor.submit(c2);

    }

}

输出：

D:\Java\jdk1.8.0_152\bin\java.exe "-javaagent:D:\Software\IntelliJ IDEA 2018.3.6\lib\idea_rt.jar=62980:D:\Software\IntelliJ IDEA 2018.3.6\bin" -Dfile.encoding=UTF-8 -classpath D:\Java\jdk1.8.0_152\jre\lib\charsets.jar;D:\Java\jdk1.8.0_152\jre\lib\deploy.jar;D:\Java\jdk1.8.0_152\jre\lib\ext\access-bridge-64.jar;D:\Java\jdk1.8.0_152\jre\lib\ext\cldrdata.jar;D:\Java\jdk1.8.0_152\jre\lib\ext\dnsns.jar;D:\Java\jdk1.8.0_152\jre\lib\ext\jaccess.jar;D:\Java\jdk1.8.0_152\jre\lib\ext\jfxrt.jar;D:\Java\jdk1.8.0_152\jre\lib\ext\localedata.jar;D:\Java\jdk1.8.0_152\jre\lib\ext\nashorn.jar;D:\Java\jdk1.8.0_152\jre\lib\ext\sunec.jar;D:\Java\jdk1.8.0_152\jre\lib\ext\sunjce_provider.jar;D:\Java\jdk1.8.0_152\jre\lib\ext\sunmscapi.jar;D:\Java\jdk1.8.0_152\jre\lib\ext\sunpkcs11.jar;D:\Java\jdk1.8.0_152\jre\lib\ext\zipfs.jar;D:\Java\jdk1.8.0_152\jre\lib\javaws.jar;D:\Java\jdk1.8.0_152\jre\lib\jce.jar;D:\Java\jdk1.8.0_152\jre\lib\jfr.jar;D:\Java\jdk1.8.0_152\jre\lib\jfxswt.jar;D:\Java\jdk1.8.0_152\jre\lib\jsse.jar;D:\Java\jdk1.8.0_152\jre\lib\management-agent.jar;D:\Java\jdk1.8.0_152\jre\lib\plugin.jar;D:\Java\jdk1.8.0_152\jre\lib\resources.jar;D:\Java\jdk1.8.0_152\jre\lib\rt.jar;F:\WorkSpace\IdeaProjects\java工具包测试\out\production\java基础测试;C:\Users\90519\.m2\repository\junit\junit\4.12\junit-4.12.jar;C:\Users\90519\.m2\repository\org\hamcrest\hamcrest-core\1.3\hamcrest-core-1.3.jar;D:\apache-maven-3.5.4\repository\org\apache\poi\poi\3.17\poi-3.17.jar;D:\apache-maven-3.5.4\repository\org\apache\poi\poi\4.0.0\poi-4.0.0.jar com.ssw.demo.MultThreadTest.ProducerAndConsumer.SingleProAndMultCon
生产者1生产了小米手机--> id: 1
生产者2生产了华为手机--> id: 2
生产者1的小米手机--> id:1被消费者1消费了
生产者2的华为手机--> id:2被消费者2消费了
生产者1生产了小米手机--> id: 3
生产者2生产了华为手机--> id: 4
生产者1生产了小米手机--> id: 5
生产者2生产了华为手机--> id: 6
生产者1的小米手机--> id:3被消费者1消费了
生产者2的华为手机--> id:4被消费者2消费了
生产者1生产了小米手机--> id: 7
生产者2的华为手机--> id:6被消费者1消费了
生产者2生产了华为手机--> id: 8
生产者1的小米手机--> id:5被消费者2消费了
生产者1的小米手机--> id:7被消费者2消费了
生产者2生产了华为手机--> id: 10
生产者1生产了小米手机--> id: 9
生产者2的华为手机--> id:8被消费者1消费了
生产者1的小米手机--> id:9被消费者1消费了
生产者2的华为手机--> id:10被消费者2消费了
生产者2生产了华为手机--> id: 11
生产者1生产了小米手机--> id: 12
生产者1生产了小米手机--> id: 13
生产者2的华为手机--> id:11被消费者2消费了
生产者1的小米手机--> id:12被消费者1消费了
生产者2生产了华为手机--> id: 14
生产者2的华为手机--> id:14被消费者1消费了
生产者1生产了小米手机--> id: 16
生产者2生产了华为手机--> id: 15
生产者1的小米手机--> id:13被消费者2消费了
生产者2生产了华为手机--> id: 17
生产者1生产了小米手机--> id: 18
生产者2的华为手机--> id:15被消费者2消费了
生产者1的小米手机--> id:16被消费者1消费了
生产者2生产了华为手机--> id: 19
生产者1的小米手机--> id:18被消费者2消费了
生产者1生产了小米手机--> id: 20
生产者2的华为手机--> id:17被消费者1消费了
生产者2生产了华为手机--> id: 21
生产者1生产了小米手机--> id: 22
生产者1的小米手机--> id:20被消费者2消费了
生产者2的华为手机--> id:19被消费者1消费了
生产者2生产了华为手机--> id: 23
生产者2的华为手机--> id:21被消费者2消费了
生产者1生产了小米手机--> id: 24
生产者1的小米手机--> id:22被消费者1消费了
生产者2的华为手机--> id:23被消费者2消费了
生产者1的小米手机--> id:24被消费者1消费了
生产者1生产了小米手机--> id: 25
生产者2生产了华为手机--> id: 26
生产者1的小米手机--> id:25被消费者1消费了
生产者2生产了华为手机--> id: 28
生产者1生产了小米手机--> id: 27
生产者2的华为手机--> id:26被消费者2消费了
生产者1生产了小米手机--> id: 29
生产者2的华为手机--> id:28被消费者1消费了
生产者2生产了华为手机--> id: 30
生产者1的小米手机--> id:27被消费者2消费了
生产者1的小米手机--> id:29被消费者1消费了
生产者2的华为手机--> id:30被消费者2消费了

参考网址

安世丶

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java使用阻塞队列实现多生产者多消费者

实体类package com.ssw.demo.MultThreadTest.ProducerAndConsumer;/** 产品信息实体类 * @author ssw * @created 2020/9/7 15:04 * @since 1.0 */public class Product { private Integer id; private String name; private String ProducerName; public Prod
复制链接

扫一扫