生产者消费者模式

最新推荐文章于 2024-07-23 10:19:57 发布
最新推荐文章于 2024-07-23 10:19:57 发布
阅读量1.6k 收藏
点赞数 1
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangzl2008/article/details/50418405
版权

Java线程之间的通信分为共享内存，消息机制，管道（PipedInputStream / PipedOutputStream）大概三种模式。生产者消费者模式是多线程问题当中一个非常经典的问题，从我们大学的《操作系统》的课本当中的位置和课时，我们便可以知道这个思想的重要性，而且在实际生产当中生产者消费者模式为我们解决了大量的并发问题。一个简单的例子，并发编程大师Doug Lea的阻塞队列便是生产者消费者模式的典型实现，这里主要使用记录一下生产者消费者模式的集中写法，并探讨一下，这集中写法所产生的不同。

1、wait() / notify()模式

import java.util.LinkedList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Created by Yang on 2015/12/14.
 */
public class MainTest01 {

    // 最大容量
    private static int MAX_SIZE = 100;

    // 共享的仓库
    private static LinkedList<String> list = new LinkedList<String>();

    private static class Productor implements Runnable {

        private int num;

        public Productor(int num) {
            this.num = num;
        }

        public void product() throws InterruptedException {
            synchronized (list) {
                while ((list.size() + num > MAX_SIZE)) {
                    System.out.println("仓库现有：" + list.size() + "；要生产：" + num + "；大于仓库容量：" + MAX_SIZE + "；暂停生产！");
                    list.wait();
                }

                // 业务逻辑
                for (int i = 0; i < num; i++) {
                    list.add("Product " + i);
                }
                System.out.println("生产了：" + num + "；仓库现有：" + list.size());
                //
                list.notifyAll();
            }
        }

        public int getNum() {
            return num;
        }

        public void setNum(int num) {
            this.num = num;
        }

        @Override
        public void run() {
            try {
                product();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private static class Consumer implements Runnable {

        private int num;

        public Consumer(int num) {
            this.num = num;
        }

        public void consume() throws InterruptedException {
            // 进入锁
            synchronized (list) {
                while (list.size() < num) {
                    System.out.println("仓库现有：" + list.size() + "；要消费：" + num + "；暂停消费！");
                    list.wait();
                }

                // 业务逻辑
                for (int i = 0; i < num; i++) {
                    list.remove();
                }
                System.out.println("消费了：" + num + "；仓库现有：" + list.size());
                //
                list.notifyAll();
            }
        }

        public int getNum() {
            return num;
        }

        public void setNum(int num) {
            this.num = num;
        }

        @Override
        public void run() {
            try {
                consume();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        executorService.execute(new Productor(10));
        executorService.execute(new Consumer(10));
        executorService.execute(new Productor(10));
        executorService.execute(new Consumer(50));
        executorService.execute(new Productor(10));
        executorService.execute(new Productor(10));
        executorService.execute(new Productor(10));
        executorService.execute(new Productor(10));
        executorService.shutdown();

    }

}

2、await() / signal()模式

import java.util.LinkedList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by Yang on 2015/12/14.
 */
public class MainTest01 {

    // 最大容量
    private static int MAX_SIZE = 100;

    // 共享的仓库
    private static LinkedList<String> list = new LinkedList<String>();

    private static final Lock lock = new ReentrantLock();

    private static final Condition notFull = lock.newCondition();

    private static final Condition notEmpty = lock.newCondition();

    private static class Productor implements Runnable {

        private int num;

        public Productor(int num) {
            this.num = num;
        }

        public void product() throws InterruptedException {
            lock.lock();
            try {
                while ((list.size() + num > MAX_SIZE)) {
                    System.out.println("仓库现有：" + list.size() + "；要生产：" + num + "；大于仓库容量：" + MAX_SIZE + "；暂停生产！");
                    notFull.await();
                }

                // 业务逻辑
                for (int i = 0; i < num; i++) {
                    list.add("Product " + i);
                }
                System.out.println("生产了：" + num + "；仓库现有：" + list.size());
                //
                notEmpty.signalAll();
            } finally {
                lock.unlock();
            }
        }

        public int getNum() {
            return num;
        }

        public void setNum(int num) {
            this.num = num;
        }

        @Override
        public void run() {
            try {
                product();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private static class Consumer implements Runnable {

        private int num;

        public Consumer(int num) {
            this.num = num;
        }

        public void consume() throws InterruptedException {
            // 进入锁
            lock.lock();
            try {
                while (list.size() < num) {
                    System.out.println("仓库现有：" + list.size() + "；要消费：" + num + "；暂停消费！");
                    notEmpty.await();
                }

                // 业务逻辑
                for (int i = 0; i < num; i++) {
                    list.remove();
                }
                System.out.println("消费了：" + num + "；仓库现有：" + list.size());
                //
                notFull.signalAll();
            } finally {
                lock.unlock();
            }
        }

        public int getNum() {
            return num;
        }

        public void setNum(int num) {
            this.num = num;
        }

        @Override
        public void run() {
            try {
                consume();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        executorService.execute(new Productor(10));
        executorService.execute(new Consumer(10));
        executorService.execute(new Productor(10));
        executorService.execute(new Consumer(50));
        executorService.execute(new Productor(10));
        executorService.execute(new Productor(10));
        executorService.execute(new Productor(10));
        executorService.execute(new Productor(10));
        executorService.shutdown();

    }

}

import java.util.LinkedList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by Yang on 2015/12/14.
 */
public class MainTest02 {

    // 最大容量
    private static int MAX_SIZE = 100;

    // 共享的仓库
    private static LinkedList<String> list = new LinkedList<String>();

    private static final Lock lock = new ReentrantLock();

    private static final Condition condition = lock.newCondition();

    private static class Productor implements Runnable {

        private int num;

        public Productor(int num) {
            this.num = num;
        }

        public void product() throws InterruptedException {
            lock.lock();
            try {
                while ((list.size() + num > MAX_SIZE)) {
                    System.out.println("仓库现有：" + list.size() + "；要生产：" + num + "；大于仓库容量：" + MAX_SIZE + "；暂停生产！");
                    condition.await();
                }

                // 业务逻辑
                for (int i = 0; i < num; i++) {
                    list.add("Product " + i);
                }
                System.out.println("生产了：" + num + "；仓库现有：" + list.size());
                //
                condition.signalAll();
            } finally {
                lock.unlock();
            }
        }

        public int getNum() {
            return num;
        }

        public void setNum(int num) {
            this.num = num;
        }

        @Override
        public void run() {
            try {
                product();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private static class Consumer implements Runnable {

        private int num;

        public Consumer(int num) {
            this.num = num;
        }

        public void consume() throws InterruptedException {
            // 进入锁
            lock.lock();
            try {
                while (list.size() < num) {
                    System.out.println("仓库现有：" + list.size() + "；要消费：" + num + "；暂停消费！");
                    condition.await();
                }

                // 业务逻辑
                for (int i = 0; i < num; i++) {
                    list.remove();
                }
                System.out.println("消费了：" + num + "；仓库现有：" + list.size());
                //
                condition.signalAll();
            } finally {
                lock.unlock();
            }
        }

        public int getNum() {
            return num;
        }

        public void setNum(int num) {
            this.num = num;
        }

        @Override
        public void run() {
            try {
                consume();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        executorService.execute(new Productor(10));
        executorService.execute(new Consumer(10));
        executorService.execute(new Productor(10));
        executorService.execute(new Consumer(50));
        executorService.execute(new Productor(10));
        executorService.execute(new Productor(10));
        executorService.execute(new Productor(10));
        executorService.execute(new Productor(10));
        executorService.shutdown();

    }

}

3、阻塞队列模式

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * Created by Yang on 2015/12/14.
 */
public class MainTest01 {

    // 最大容量
    private static int MAX_SIZE = 100;

    // 共享的仓库
    private static LinkedBlockingQueue<String> list = new LinkedBlockingQueue<String>(MAX_SIZE);

    private static class Productor implements Runnable {

        private int num;

        public Productor(int num) {
            this.num = num;
        }

        public void product() throws InterruptedException {
            if ((list.size() + num > MAX_SIZE)) {
                System.out.println("仓库现有：" + list.size() + "；要生产：" + num + "；大于仓库容量：" + MAX_SIZE + "；暂停生产！");
            }

            // 业务逻辑
            for (int i = 0; i < num; i++) {
                list.put("Product " + i);
            }
            System.out.println("生产了：" + num + "；仓库现有：" + list.size());
            //
        }

        public int getNum() {
            return num;
        }

        public void setNum(int num) {
            this.num = num;
        }

        @Override
        public void run() {
            try {
                product();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private static class Consumer implements Runnable {

        private int num;

        public Consumer(int num) {
            this.num = num;
        }

        public void consume() throws InterruptedException {
            if (list.size() < num) {
                System.out.println("仓库现有：" + list.size() + "；要消费：" + num + "；暂停消费！");
            }

            // 业务逻辑
            for (int i = 0; i < num; i++) {
                list.take();
            }
            System.out.println("消费了：" + num + "；仓库现有：" + list.size());
            //
        }

        public int getNum() {
            return num;
        }

        public void setNum(int num) {
            this.num = num;
        }

        @Override
        public void run() {
            try {
                consume();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        executorService.execute(new Productor(10));
        executorService.execute(new Consumer(10));
        executorService.execute(new Productor(10));
        executorService.execute(new Consumer(50));
        executorService.execute(new Productor(10));
        executorService.execute(new Productor(10));
        executorService.execute(new Productor(10));
        executorService.execute(new Productor(10));
        executorService.shutdown();

    }

}






Snowball
关注
专栏目录
labview 基于事件的生产者消费者模式
03-17
labview 基于事件的生产者消费者模式
生产者/消费者模式(转载)
w57w57w57的专栏
09-07 3430
★简介     在实际的软件开发过程中，经常会碰到如下场景：某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。     单单抽象出生产者和消费者，还够不上是生产者／消费者模式。该模式还需要有一个缓冲区处于生产者和消费者之间，作为一个中介。生产者把数据放入缓冲区，而
【生产-消费模型】生产者 - 消费者模型原理及实现
最新发布
qq_38089448的博客
07-23 1202
假设有两个进程（或线程）A、B和一个固定大小的缓冲区，A进程生产数据放入缓冲区，B进程从缓冲区中取出数据进行计算，这就是一个简单的生产者-消费者模型。这里的A进程相当于生产者，B进程相当于消费者。
Java多线程生产者消费者模式实现过程解析
08-19
Java多线程生产者消费者模式实现过程解析 Java多线程生产者消费者模式是指在Java编程中，使用多线程来实现生产者和消费者之间的数据交换 и处理的模式。该模式下，生产者负责产生数据，而消费者负责处理数据。这种...
Java生产者消费者模式实例分析
08-26
Java生产者消费者模式实例分析 Java生产者消费者模式是一种常见的设计模式，它广泛应用于Java多线程编程中。该模式主要由三个部分组成：生产者、消费者和缓存。下面对Java生产者消费者模式的相关组成、原理及实现...
Lock、Condition实现简单的生产者消费者模式示例
09-04
在Java多线程编程中，生产者消费者模式是一种常见的设计模式，用于协调生产者线程和消费者线程之间的协作，确保资源的有效利用和同步。在这个示例中，使用了Java的`java.util.concurrent.locks`包中的`Lock`接口和`...
基于Java 生产者消费者模式(详细分析)
08-28
基于Java生产者消费者模式详细分析 一、生产者消费者模式概述 生产者消费者模式是多线程中最为常见的模式。生产者线程（一个或多个）生成面包放入篮子里（集合或数组），同时，消费者线程（一个或多个）从篮子里...
C语言实现操作系统中生产者消费者
06-26
用C-Free5软件写的，主函数为Int类型。在其他软件上可能要改成void，算法方面没有什么问题。如果要缓冲池满就把生产者M1的数改的比消费者M2的高，要缓冲池空则相反。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值