使用wait notify实现生产者消费者模型

水深无声 2022-09-01 00:59 95阅读 0赞

一个内存队列，多个生产者线程往内存队列中放数据;多个消费者线程从内存队列中取数据  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTAyOTI4Ng_size_16_color_FFFFFF_t_70]  
使用wait()与notify()机制  
队列的实现

public class MyQueue {
        
        /**
         * 数组队列（总长度为10）
         */
        private String[] data = new String[10];
        /**
         * 出队列的下标
         */
        private int getIndex = 0;
        /**
         * 入队列的下标
         */
        private int putIndex = 0;
        /**
         * 队列已使用的长度
         */
        private int size = 0;
    
        /**
         * 入队列前尝试获取锁
         * @param element
         */
        public synchronized void put(String element) {
        
            /**
             * 进入方法表示已经获取到了锁
             * 判断是否达到了队列的最大长度，如果达到了最大长度则wait，如果没有则进行put0的入队列逻辑，入队列完成后notify唤醒其他线程
             */
            if (size == data.length) {
        
                try {
        
                    wait();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                //这里从wait状态被唤醒后需要重新进入put方法判断是否达到队列的最大长度
                put(element);
            } else {
        
                put0(element);
                notify();
            }
        }
    
        /**
         * 入队列
         * @param element
         */
        private void put0(String element) {
        
            //把当前element放进队列，然后putIndex下标+1
            data[putIndex] = element;
            ++putIndex;
            //如果putIndex到达数组尾部，则重新从队列头开始存入
            if (putIndex == data.length) {
        
                putIndex = 0;
            }
            ++size;
        }
    
        /**
         * 出队列前尝试获取锁
         * @return
         */
        public synchronized String get() {
        
            //判断队列是否已经空了
            //如果空了则等待
            if (size == 0) {
        
                try {
        
                    wait();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                //被唤醒，然后重新判断是否是空队列
                return get();
            } else {
        
                //出队列
                String result = get0();
                //唤醒其他线程
                notify();
                return result;
            }
        }
    
        /**
         * 出队列
         * @return
         */
        private String get0() {
        
            //依次从getIndex向后取，这次取getIndex的，下次进入get0方法就取getIndex+1的
            String result = data[getIndex];
            ++getIndex;
            //如果getIndex到达数组的最大值，则从队列头开始取
            if (getIndex == data.length) {
        
                getIndex = 0;
            }
            --size;
            return result;
        }
    }

生产者

/**
     * 生产者
     */
    public class ProducerThread extends Thread {
        
        private final MyQueue myQueue;
        private final Random random = new Random();
        private int index = 0;
    
    
        public ProducerThread(MyQueue myQueue) {
        
            this.myQueue = myQueue;
        }
    
        @Override
        public void run() {
        
            //不停的生产
            while (true) {
        
                String tmp = "ele-"+Thread.currentThread().getName()+"-" + index;
                //put方法有synchronize，锁的是myQueue自己
                myQueue.put(tmp);
                System.out.println("添加元素:" + tmp);
                index++;
                try {
        
                    Thread.sleep(random.nextInt(1000));
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
        }
    }

消费者

/**
     * 消费者
     */
    public class ConsumerThread extends Thread {
        
        private final MyQueue myQueue;
        private final Random random = new Random();
    
        
        public ConsumerThread(MyQueue myQueue) {
        
            this.myQueue = myQueue;
        }
    
        @Override
        public void run() {
        
            while (true) {
        
                //get方法有synchronize，锁的是myQueue自己
                String s = myQueue.get();
                System.out.println("\t\t消费元素:" + s);
                try {
        
                    Thread.sleep(random.nextInt(1000));
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
        }
    }

测试代码

public class Main {
        
        public static void main(String[] args) {
        
            MyQueue myQueue = new MyQueue();
            for (int i = 0; i < 3; i++) {
        
                //消费者消费同一个队列
                new ConsumerThread(myQueue).start();
            }
            for (int i = 0; i < 5; i++) {
        
                //生产者放入同一个队列
                new ProducerThread(myQueue).start();
            }
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTAyOTI4Ng_size_16_color_FFFFFF_t_70 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTAyOTI4Ng_size_16_color_FFFFFF_t_70]: /images/20220829/a47d71a85ba64c58a76fe9f5279e914c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTAyOTI4Ng_size_16_color_FFFFFF_t_70 1]: /images/20220829/61b166bb8739466c8e9c12526a076162.png

发表评论取消回复

表情：

评论列表（有 0 条评论，95人围观）

还没有评论，来说两句吧...

相关阅读

相关 19 使用wait和notify/notifyall 实现生产者消费者

写一个固定容量同步容器，拥有put和get方法，以及getCount方法，能够支持2个生产者线程以及10个消费者线程的阻塞调用 (使用wait和notify/noti...

川长思鸟来/ 2024年04月18日 17:46/ 0 赞/ 21 阅读

相关 Java随笔记 - 用wait()和notify()实现生产者消费者模型

Java随笔记 - 用wait()和notify()实现生产者消费者模型生产者消费者问题在多线程的相关基础知识中，生产者消费者是一个很经典的问题。理论上

水深无声/ 2023年01月02日 12:20/ 0 赞/ 79 阅读

相关 notify 和 wait 实现生产者消费者模型

1. 对于wait()和notify()的理解 void notify() 唤醒在此对象监视器上等待的单个线程 void notifyAl

拼搏现实的明天。/ 2022年10月12日 05:57/ 0 赞/ 145 阅读

相关使用wait notify实现生产者消费者模型

一个内存队列，多个生产者线程往内存队列中放数据;多个消费者线程从内存队列中取数据 ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpd

水深无声/ 2022年09月01日 00:59/ 0 赞/ 96 阅读

相关使用wait和notifyAll实现生产者消费者模型

wait和notifyAll是JDK中Object类的两个方法，主要用来线程间通讯，最经典的应用场景就是【生产者-消费者】，下面给出简单示例。 / @Auothor

悠悠/ 2022年06月16日 06:11/ 0 赞/ 88 阅读

相关 notify和wait实现生产者与消费者

生产者和消费者模式，当缓冲区里面没有数据，生产者生产数据到缓冲区中；当缓冲区里面有数据生产者就阻塞，消费者就从换城区里面消费数据； --------------

待我称王封你为后i/ 2022年05月14日 05:50/ 0 赞/ 115 阅读

相关通过wait和notify实现的生产者消费者demo

Java代码 : import java.util.ArrayList; import java.util.List; /\\ \ 通过wait和notify实

迷南。/ 2022年04月15日 07:44/ 0 赞/ 104 阅读

相关使用wait()和notify()方法实现生产者消费者模式

以下总结只是个人理解，如有错误，敬请指正。一、wait()和notify()作用 wait()和notify()方法是Object类的方法，因为Object类是所有类的根

忘是亡心i/ 2022年03月22日 03:27/ 0 赞/ 130 阅读

相关生产者和消费者三种实现:wait/notify、lock、disruptor

第一种 wait/notify+链表实现生产者 / @author sunchangtan @date 2019/2/25 12:59 / pub

淡淡的烟草味﹌/ 2022年02月23日 05:58/ 0 赞/ 131 阅读

相关 wait-notifyAll实现生产者与消费者模型

前述生产者与消费者问题是线程并发问题中一个重要的内容，java有多种实现方式，而利用线程wait和notifyAll可以简单实现生产与消费并发的思想。关键

雨点打透心脏的1/2处/ 2022年01月27日 14:23/ 0 赞/ 133 阅读