生产者消费者问题-代码详解（Java多线程）

缺乏、安全感 2023-10-06 10:56 19阅读 0赞

> 你好我是辰兮，很高兴你能来阅读，本篇是整理了Java多线程中常见的生产者消费者问题，也是面试手写代码的高频问题，分享获取新知，大家共同进步！

*  `1.JAVA基础面试常考问题` ： [JAVA面试基础常考题汇集][JAVA]
 *  `2.JAVA面试SSM框架常考` ：[JAVA框架面试题汇集][JAVA 1]

--------------------

#### 文章目录 ####

*   *   *  一、生产者消费者问题
         *  二、代码实现
         *  三、拓展知识

--------------------

#### 一、生产者消费者问题 ####

生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。

该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。

![在这里插入图片描述][20200612122000483.png]  
生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。

--------------------

生产消费者模型

生产者消费者模型具体来讲，就是在一个系统中，存在生产者和消费者两种角色，他们通过内存缓冲区进行通信，生产者生产消费者需要的资料，消费者把资料做成产品。生产消费者模式如下图。

![在这里插入图片描述][20200612121712163.png]

--------------------

#### 二、代码实现 ####

案例如下

![在这里插入图片描述][20200612132242715.png]  
　首先定义一个类 ，这个类创建一个长度为5的数组，然后用synchronized同步锁实现生产数据和消费数据两个方法，两个方法中分别有 wait()和notify();

public class Resources {
        
    
        private int[] arr = new int[5];
        private int count = 0;
    
        /**
         * 生产一个数据
         */
        synchronized public void product() throws Exception {
        
            if(count == arr.length) {
        
                wait();
            }else {
        
                int m =  (int)Math.floor(Math.random()*10+1) ;
                arr[count] = m;
                count ++ ;
                System.out.println("生产："+m);
                //唤醒消费者
                notify();
            }
        }
    
        /**
         * 消费一个数据
         */
        synchronized public void consume() throws Exception {
        
            if(count == 0) {
        
                wait();
            }else {
        
                int n = arr[count-1];
                arr[count-1] = 0;
                count--;
                System.out.println("消费："+n);
                //唤醒生产者
                notify();
            }
        }
    }

然后创建生产者线程，引入刚刚的对象，用刚刚的对象调用生产的方法

public class ProduceThread extends Thread {
        
        private Resources r;
        public ProduceThread(Resources r) {
        
            this.r = r;
        }
        public void run() {
        
            try {
        
                while(true) {
        
                    r.product();
                    Thread.sleep(1);
                }
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }

然后创建消费者线程，同样引入Resources对象，然后再用这个对象调用消费数据的方法

public class ConsumerThread extends Thread {
        
        private Resources r;
        public ConsumerThread(Resources r) {
        
            this.r = r;
        }
        public void run() {
        
            try {
        
                while(true) {
        
                    r.consume();
                    Thread.sleep(1);
                }
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }

测试类开始测试

public class Test {
        
    
        public static void main(String[] args) {
        
    
            Resources r = new Resources();
    
            ProduceThread t1 = new ProduceThread(r);
            ConsumerThread t2 = new ConsumerThread(r);
    
            t1.start();
            t2.start();
        }
    
    }

在main方法中，开启消费者和生产者线程。因为生产者和消费者用的是同一个对象的不同synchronized方法，所以两个线程会产生producterAndConsumer 对象锁的竞争

生产：4
    消费：4
    生产：7
    消费：7
    生产：8
    生产：4
    消费：4
    消费：8
    生产：4
    消费：4
    生产：2
    消费：2
    生产：8
    生产：5
    消费：5
    消费：8
    生产：3
    生产：1
    .....//无休止

--------------------

#### 三、拓展知识 ####

1、为什么wait, notify 和 notifyAll这些方法不在thread类里面？

①JAVA提供的锁是对象级的而不是线程级的（如我例子中的list，list是对象），每个对象都有锁，通过线程获得。

②如果线程需要等待某些锁那么调用对象中的wait()方法就有意义了。如果wait()方法定义在Thread类中，线程正在等待的是哪个锁就不明显了。

③简单的说，由于wait，notify和notifyAll都是锁级别的操作，所以把他们定义在Object类中因为锁属于对象。

--------------------

补充：如何理解Java 中每个对象都有个锁？

在Java语言中，每一个对象有一把锁。线程可以使用synchronized关键字来获取对象上的锁。

java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，从而保证了该变量的唯一性和准确性。

--------------------

2、java中notify 和 notifyAll有什么区别？

notify()notifyAll()的共同点：

均能唤醒正在等待的线程，并且均是最后只有一个线程获取资源对象的锁。

notify()notifyAll()的不同点：

notify() 只能唤醒一个线程，而notifyall()能够唤醒所有的线程，当线程被唤醒以后所有被唤醒的线程竞争获取资源对象的锁，其中只有一个能够得到对象锁，执行代码。注意：wait()方法并不是在等待资源的锁，而是在等待被唤醒。

--------------------

3、未完待续.

--------------------

`The best investment is to invest in yourself`

![在这里插入图片描述][20200504104023371.jpg]

`2020.06.13 记录辰兮的第81篇博客`

[JAVA]: https://blog.csdn.net/weixin_45393094/article/details/104816195
[JAVA 1]: https://blog.csdn.net/weixin_45393094/article/details/104878236
[20200612122000483.png]: https://img-blog.csdnimg.cn/20200612122000483.png
[20200612121712163.png]: https://img-blog.csdnimg.cn/20200612121712163.png
[20200612132242715.png]: https://img-blog.csdnimg.cn/20200612132242715.png
[20200504104023371.jpg]: https://img-blog.csdnimg.cn/20200504104023371.jpg