面试：手写代码生产者和消费者实现

最新推荐文章于 2022-11-13 16:47:12 发布
最新推荐文章于 2022-11-13 16:47:12 发布
阅读量124 收藏
点赞数
文章标签： 面试 c/c++ java
原文链接：http://www.cnblogs.com/nicoleljc/p/9980632.html
版权
生产者消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一存储空间，生产者向空间里生产数据，而消费者取走数据。
 
1. 使用阻塞队列实现生产者消费者模式

生产者：

 1 public class Producer implements Runable{
 2     private final BlockingQueue sharedQueue;
 3     public Producer(BlockingQueue sharedQueue){
 4     this.sharedQueue = sharedQueue;
 5     }
 6     
 7     publlic void run(){
 8     for(i=0;i<10;i++){
 9         try{
10             System.out.println("Producer:"+i);
11             sharedQueue.put(i);
12             }catch(InterruptedException ex){
13                 System.out.println("exception:"+ex);
14               }
15             }
16     }
17 }

消费者：

public class Consumer implements Runable{
        private final BlockingQueue sharedQueue;
        public Consumer(BlockingQueue sharedQueue){
            this.sharedQueue = sharedQueue 
        }
        
        public void run(){
             while(true){
                try{
                        System.out.println("Consumed:"+sharedQueue.take());
                }catch(InterruptedException ex){
                        System.out.println("Exception:"+ex);
                }
             }
        }
}

生产者消费者模式：

public class ProducerConsumerPattern {
    private static final Logger logger = 
    public static void main(String[] args) {
        //阻塞队列
        BlockingQueue sharedQueue = new LinkedBlockingDeque();

        //创建生产者和消费者，共享队列
        Thread prodThread = new Thread(new Producer(sharedQueue));
        Thread consThread = new Thread(new Consumer(sharedQueue));

        //开启生产者和消费者进程
        prodThread.start();
        consThread.start();
    }
}

BlockingQueue是一个阻塞队列，它的存取可以保证只有一个线程在进行，所以根据逻辑，生产者在内存满的时候进行等待，并且唤醒消费者队列，反过来消费者在饥饿状态下等待并唤醒生产者进行生产。

2. wait/notify方法实现

/**
 * 生产者消费者模式：使用Object.wait() / notify()方法实现
 */
public class ProducerConsumer {
    private static final int CAPACITY = 5;

    public static void main(String args[]){
        Queue<Integer> queue = new LinkedList<Integer>();

        Thread producer1 = new Producer("P-1", queue, CAPACITY);
        Thread producer2 = new Producer("P-2", queue, CAPACITY);
        Thread consumer1 = new Consumer("C1", queue, CAPACITY);
        Thread consumer2 = new Consumer("C2", queue, CAPACITY);
        Thread consumer3 = new Consumer("C3", queue, CAPACITY);

        producer1.start();
        producer2.start();
        consumer1.start();
        consumer2.start();
        consumer3.start();
    }

    /**
     * 生产者
     */
    public static class Producer extends Thread{
        private Queue<Integer> queue;
        String name;
        int maxSize;
        int i = 0;

        public Producer(String name, Queue<Integer> queue, int maxSize){
            super(name);
            this.name = name;
            this.queue = queue;
            this.maxSize = maxSize;
        }

        @Override
        public void run(){
            while(true){
                synchronized(queue){
                    while(queue.size() == maxSize){
                        try {
                            System.out .println("Queue is full, Producer[" + name + "] thread waiting for " + "consumer to take something from queue.");
                            queue.wait();
                        } catch (Exception ex) {
                            ex.printStackTrace();
                        }
                    }
                    System.out.println("[" + name + "] Producing value : +" + i);
                    queue.offer(i++);
                    queue.notifyAll();

                    try {

                        Thread.sleep(new Random().nextInt(1000));//模拟随机生产
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }

        }
    }

    /**
     * 消费者
     */
    public static class Consumer extends Thread{
        private Queue<Integer> queue;
        String name;
        int maxSize;

        public Consumer(String name, Queue<Integer> queue, int maxSize){
            super(name);
            this.name = name;
            this.queue = queue;
            this.maxSize = maxSize;
        }

        @Override
        public void run(){
            while(true){
                synchronized(queue){
                    while(queue.isEmpty()){
                        try {
                            System.out.println("Queue is empty, Consumer[" + name + "] thread is waiting for Producer");
                            queue.wait();
                        } catch (Exception ex) {
                            ex.printStackTrace();
                        }
                    }
                    int x = queue.poll();
                    System.out.println("[" + name + "] Consuming value : " + x);
                    queue.notifyAll();

                    try {
                        Thread.sleep(new Random().nextInt(1000));//模拟随机消费
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}
  • wait()：当缓冲区已满/空时，生产者/消费者线程停止自己的执行，放弃锁，使自己处于等待状态，让其他线程执行。
  • notify()：当生产者/消费者向缓冲区放入/取出一个产品时，向其他等待的线程发出可执行的通知，同时放弃锁，使自己处于等待状态。
3. 使用Lock和Condition的await() / signal()方法
/**
 * 生产者消费者模式：使用Lock和Condition实现
 * {@link java.util.concurrent.locks.Lock}
 * {@link java.util.concurrent.locks.Condition}
 */
public class ProducerConsumerByLock {
    private static final int CAPACITY = 5;
    private static final Lock lock = new ReentrantLock();
    private static final Condition fullCondition = lock.newCondition();     //队列满的条件
    private static final Condition emptyCondition = lock.newCondition();        //队列空的条件


    public static void main(String args[]){
        Queue<Integer> queue = new LinkedList<Integer>();

        Thread producer1 = new Producer("P-1", queue, CAPACITY);
        Thread producer2 = new Producer("P-2", queue, CAPACITY);
        Thread consumer1 = new Consumer("C1", queue, CAPACITY);
        Thread consumer2 = new Consumer("C2", queue, CAPACITY);
        Thread consumer3 = new Consumer("C3", queue, CAPACITY);

        producer1.start();
        producer2.start();
        consumer1.start();
        consumer2.start();
        consumer3.start();
    }

    /**
     * 生产者
     */
    public static class Producer extends Thread{
        private Queue<Integer> queue;
        String name;
        int maxSize;
        int i = 0;

        public Producer(String name, Queue<Integer> queue, int maxSize){
            super(name);
            this.name = name;
            this.queue = queue;
            this.maxSize = maxSize;
        }

        @Override
        public void run(){
            while(true){

                //获得锁
                lock.lock();
                while(queue.size() == maxSize){
                    try {
                        System.out .println("Queue is full, Producer[" + name + "] thread waiting for " + "consumer to take something from queue.");
                        //条件不满足，生产阻塞
                        fullCondition.await();
                    } catch (InterruptedException ex) {
                        ex.printStackTrace();
                    }
                }
                System.out.println("[" + name + "] Producing value : +" + i);
                queue.offer(i++);

                //唤醒其他所有生产者、消费者
                fullCondition.signalAll();
                emptyCondition.signalAll();

                //释放锁
                lock.unlock();

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

        }
    }

    /**
     * 消费者
     */
    public static class Consumer extends Thread{
        private Queue<Integer> queue;
        String name;
        int maxSize;

        public Consumer(String name, Queue<Integer> queue, int maxSize){
            super(name);
            this.name = name;
            this.queue = queue;
            this.maxSize = maxSize;
        }

        @Override
        public void run(){
            while(true){
                //获得锁
                lock.lock();

                while(queue.isEmpty()){
                    try {
                        System.out.println("Queue is empty, Consumer[" + name + "] thread is waiting for Producer");
                        //条件不满足，消费阻塞
                        emptyCondition.await();
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                }
                int x = queue.poll();
                System.out.println("[" + name + "] Consuming value : " + x);

                //唤醒其他所有生产者、消费者
                fullCondition.signalAll();
                emptyCondition.signalAll();

                //释放锁
                lock.unlock();

                try {
                    Thread.sleep(new Random().nextInt(1000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
4. 总结

实现生产者消费者模式有3点：

1. 拿什么作为缓冲区，给生产者和消费者解耦，平衡了生产者和消费者的处理能力。一般使用队列

2. 构建生产者，队列满使得生产者线程阻塞

3. 构建消费者 ，队列空使得消费者现成阻塞

参考：https://blog.csdn.net/u010983881/article/details/78554671

转载于:https://www.cnblogs.com/nicoleljc/p/9980632.html

weixin_30455661
关注
Java岗位面试--单例模式、生产者消费者线程同步
太阳当空照，花儿对我笑，微风轻轻拂，心情无限好。
08-04 55
答：一个类的构造函数私有化，然后在类中定义一个私有静态变量，通过一个静态函数get获得私有变量实例即可实现单例。如果想要懒加载，可以用上双重检验锁在get函数中。9.手写一个生产者消费者模式，用的ReentrantLock，为什么判断当前count是否满足生产或者消费时用while。4.用volatile+synchronized写一个单例模式，用双重校验锁方法，说出两个if判断语句的作用。写个单例保证线程安全(虽然写出了，但被问住了，告诉我代码不能死记硬背)10.手写单例模式 1.写一个单例模式，
阿里实习笔试题-- JAVA实现单生产者多消费者问题变种
silent_gods的博客
07-25 544
心得体会： 生产者消费者问题是一个经典的问题。平时对这种理论理解的比较到位。以为自己已经掌握了，没想到拿到了IDE,没有任何提示，用记事本让我写出来，还是表现得很不好。对于各种理论都知道，但是知道是一回事。能够手写出来是一回事，经过这一次阿里的面试，发现自己在实际编码能力上面有些缺乏。 毕竟一直都在做算法题。一遇到工程题总是会很慌，从而束手无策，另外阿里的面试官的水平很高。第三面的时候和我讨论这个...
面试官让我手写一个生产者消费者模式
烟雨星空的博客
02-25 1721
不知道你是否遇到过面试官让你手写生产者消费者代码。别说，前段时间有小伙伴还真的遇到了这种情况。当时是一脸懵逼。 但是，俗话说，从哪里跌倒就要从哪里爬起来。既然这次被问到了，那就回去好好研究一下，争取下一次不再被虐呗。 于是，今天我决定手敲一个生产者消费者模式压压惊。（因为我也不想以后被面试官血虐啊） 生产者消费者模式，其实很简单。无非就是生产者不停的生产数据，消费者不停的消费数据。（这不废话吗，字...
【Java多线程手写代码】（五）：如何优雅的实现生产者、消费者
少侠露飞的学习笔记
11-23 605
腾讯面试官让我手动实现生产者、消费者
线程简单问题
li953348869的博客
06-03 243
1.线程安全：如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。 2. Java中notify 和 notifyAll有什么区别？ 因为多线程可以等待单监控锁，Java API 的设计人员提供了一些方法当等待条件改变的时候通知它们，但是这些方法没有完全实现。noti
【经典面试题】生产者消费者模型
enjoymyselflzz的博客
08-22 1675
条件变量 条件变量是利用线程间共享的全局变量进行同步的一种机制。主要包括两个动作：一个线程等待“条件变量的条件成立”而挂起，另一个线程让“条件成立（给出条件成立信号）” 作用：为了防止竞争 注意事项：条件变量的使用总是和一个互斥锁结合在一起 1.pthread_cond_t cond;    //定义条件变量的全局变量 2.pthread_cond_init（&amp;cond,NULL...
C++实现生产者消费者
欢迎来到打不死的小强的专栏
09-02 873
#include <condition_variable> #include <mutex> #include <thread> #include <iostream> #include <queue> #include <chrono>int main() { // 生产者数量 std::queue<int> produced_nums; // 互斥锁 std::m
阿里面试题：手写两个线程一个线程打印1，一个线程打印0，依次交替
大黄奔跑
05-16 1114
阿里一面上来就让手写一个多线程模型，利用condition来实现1和0的交替执行，着实把我弄懵逼了，凭借着自己微弱的记忆，大致写出了如下： 基本思路是： 1、线程 操作 (方法) 资源类 2、判断 干活 通知 3、利用while判断来防止虚假唤醒机制 第一种方法利用Lock进行加锁解锁： public class ProducerAndConsumer { public static void main(String[] args)
高并发面试：线程池的七大参数？手写一个线程池？
msbz7的博客
09-02 323
/corePoolSize:常驻核心线程数2,//maximumPoolSize:最大的可容纳线程数5,//存活时间设置为1s1L,//这里用LinkedBlockingQueue，且容量为3，意味着等候区最大容量三个任务//默认的defaultThreadFactory即可//丢弃方法使用AbortPolicy()//这里用来做任务的处理执行i < 5;i++) {
描述消费者和生产者模式的代码（有些公司面试的时候会让你直接写一段代码）
u011212549的博客
07-29 425
package thread; /** * 生产者消费者模式 * @author 编程只服JAVA * */ public class ProducerConsumer { public static void main(String[] args) { SyncStack ss=new SyncStack(); Producer producer=new Producer(s
生产者 消费者 模式 c++
04-25
生产者 消费者 模式 c++ 算是老外写的一个使用demo 可以参考一下
生产者与消费者源代码加测试文件
12-21
此文件是我在os课上编写调试的，包含生产者与消费者的线程同步问题的解决源程序，有注释清晰。注意包含了一个测试文件，大家再也不用因为下了源程序而没有测试文件而发愁，测试文件结构清晰，有助于了解线程的数据结构。
手写一个生产者消费者模式
yeguangchen的博客
08-15 640
用wait/notify实现开发者消费者模式，之前博客使用阻塞队列BlockingQueue也实现过开发者消费者模式。 以下的代码和main方法都写在一个文件里就行。 第一步：我们首先需要一个容器storage，我们将它定义为LinkedList是为了使用它的poll方法，一步实现拿出并删除，当然也可以使用ArrayList，然后使用get(0) + remove()拿出删除产品。 这个容器类一个干了三件事，1.定义容器并初始化。2.实现往容器放产品，即创建put方法，供生产者调用。3.实现从容器里取出
C++面试：手写实现生产者消费者模型
weixin_42869227的博客
04-22 1288
#include<bits/stdc++.h> using namespace std; template<typename T> class Queue { public: Queue(int maxn = 50):maxnsize(maxn){} //生产者 bool Push(const T& elm) { unique_lock<mutex> ulk(_mtx); if(_qu
手写生产者/消费者模式（三种实现方式）
洋葱专栏-有灵魂的程序员
08-10 681
生产者消费者模式需要满足： 1）生产者生产数据到缓冲区中，消费者从缓冲区中取数据； 2）缓冲区蛮，生产者线程阻塞； 3）缓冲区为空，消费者线程阻塞； 分析 1）定义缓存队列，选择一个集合当作缓存，给与缓存上线，缓存队列只有两种行为（生产数据和消费数据）。 2）定义生产者线程，调用缓存队列中的生产行为； 3）定义消费者线程，调用缓存队列中的消费者行为 第一种方式： 双向链表Link...
生产者-消费者C++实现（二）
最新发布
flyingshineangel的专栏
11-13 1628
上面代码实现了生产者——消费者基本功能，由于生产者（proucer_callback）和消费者（consumer_callback）都通过sleep控制了速度，没有出现产品缓冲区为空，而消费者一直循环获取互斥锁（没有产品消费，消费者在空轮，造成cpu资源浪费，影响消费者），而生产者没有机会获取互斥锁的情况，但实际情况不可能通过sleep去控制，这样将会使处理性能大打折扣。第一点需求是显然的，即便是在生产线程和消费线程速率相当的情况下，增加缓冲区也是有益的，这样能够减少生产者抖动（如网络）带来的影响；
生产者消费者测试
lishenglong666的专栏
05-26 575
#include #include #include using namespace std; pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t event = PTHREAD_COND_INITIALIZER; int num = 0; int countP = 0; bool
手写一个生产者--消费者模型例子
06-26 7945
在并发编程中，比较经典的编程例子就是生产者和消费者模型。下面就是一个例子来诠释一下什么是生产者和消费者以及他们的特点和注意点。1、先定义一个数据对象，public class Data { private String id; private String name; public Data(String id,String name){ this.id = id
生产者消费者代码_面试官让我手写一个生产者消费者模式
weixin_39898380的博客
12-02 66
不知道你是否遇到过面试官让你手写生产者消费者代码。别说，前段时间有小伙伴还真的遇到了这种情况。当时是一脸懵逼。但是，俗话说，从哪里跌倒就要从哪里爬起来。既然这次被问到了，那就回去好好研究一下，争取下一次不再被虐呗。于是，今天我决定手敲一个生产者消费者模式压压惊。(因为我也不想以后被面试官血虐啊)生产者消费者模式，其实很简单。无非就是生产者不停的生产数据，消费者不停的消费数据。(这不废话吗，字面意思...
前端面试：手写代码技巧——数组去重与快速排序实现
在JavaScript前端面试中，手写代码是一个常见的环节，旨在评估面试者的数据结构和算法基础。本篇文章主要讨论了两种数组去重的方法：基本的遍历和利用哈希表（对象）的方式。 1. **数组去重基础方法** - **基本遍...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值