Lock实现生产者消费者问题

古城微笑少年丶 2023-10-05 16:58 15阅读 0赞

什么是生产者消费者问题？

> 所谓的生产者消费者问题，是通过一个容器来解决生产者和消费者的强耦合问题。通俗的讲，就是生产者在不断的生产，消费者也在不断的消费，可是消费者消费的产品是生产者生产的，这就必然存在一个中间容器，我们可以把这个容器想象成是一个货架，当货架空的时候，生产者要生产产品，此时消费者在等待生产者往货架上生产产品，而当货架满的时候，消费者可以从货架上拿走商品，生产者此时等待货架的空位，这样不断的循环。那么在这个过程中，生产者和消费者是不直接接触的，所谓的‘货架’其实就是一个阻塞队列，生产者生产的产品不直接给消费者消费，而是仍给阻塞队列，这个阻塞队列就是来解决生产者消费者的强耦合的。就是生产者消费者问题。

### 那生产者消费者问题有什么用？ ###

*  生产与消费的速度不匹配
 *  软件开发过程中解耦

这篇文章通过JUC中的Lock接口来实现生产者消费者问题；  
首先，我们得知道知道几个知识点：

### Lock ###

> lock锁是JDK1.5之后推出的一种锁机制，可以通过使用ReentrantLock实现类来实现实现线程之间的同步互斥，且在使用上比synchronized更加灵活。

查看JDK帮助文档，我们得知Lock锁的简单使用:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTc5NjI5_size_16_color_FFFFFF_t_70]

### Condition ###

> 回忆 synchronized 关键字，它配合 Object 的 wait()、notify() 系列方法可以实现等待/通知模式。对于 Lock，通过 Condition 也可以实现等待/通知模式。Condition是在java 1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、notify()，使用Condition的await()、signal()这种方式实现线程间协作更加安全和高效。

查看JDK帮助文档，我们知道这个接口的实现类和使用方法:

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTc5NjI5_size_16_color_FFFFFF_t_70 1]  
当我们了解完上面几个知识点，这时候我们就可以去写一个生产者消费者问题例子:

/**
     * 通过Lock锁来实现生产者和消费者问题
     */
    public class ProducerAndConsumer2 {
        
    
        public static void main(String[] args) {
        
            ProAndCon2 proAndCon2 = new ProAndCon2();
            new Thread(()->{
        
                for (int i = 0; i < 5; i++) {
        
                        proAndCon2.Pro();
                }
            },"A").start();
    
            new Thread(()->{
         //让B线程去执行消费者方法
                for (int i = 0; i < 5; i++) {
        
                        proAndCon2.Con();
                }
            },"B").start();
            new Thread(()->{
        
                for (int i = 0; i < 5; i++) {
        
                        proAndCon2.Pro();
                }
            },"C").start();
    
            new Thread(()->{
        
                for (int i = 0; i < 5; i++) {
        
                        proAndCon2.Con();
                }
            },"D").start();
        }
    }
    
    /**
     * 在 Lock取代 synchronized方法和语句的使用，一个 Condition取代对象监视器的使用方法。
     */
    class ProAndCon2{
        
        private int num=0; //创建一个公共变量
    
        //创建可重入锁对象
        Lock lock=new ReentrantLock();  //可以取代synchronized
    
        //创建Condition对象(用于监听)
       Condition condition=lock.newCondition();//取代对象监视器的使用方法。 例如wait notifyAll等等
    
        //生产者方法
        public void Pro(){
        
       //开启锁
            lock.lock();
            try {
        
                while (num !=0){
        
                    condition.await();//等待
                }
                num++;
                System.out.println(Thread.currentThread().getName()+"->"+num);
                condition.signalAll();//唤醒所有线程
            } catch (Exception e) {
        
                e.printStackTrace();
            } finally {
        
                lock.unlock();
            }
        }
    
        //消费者方法
        public  void Con(){
        
            //开启锁
            lock.lock();
            try {
        
                while (num==0){
        
                  condition.await();
                }
                num--;
                System.out.println(Thread.currentThread().getName()+"->"+num);
                condition.signalAll();//唤醒所有线程
            } catch (Exception e) {
        
                e.printStackTrace();
            } finally {
        
                lock.unlock();
            }
        }
    }

**结果如下：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTc5NjI5_size_16_color_FFFFFF_t_70 2]

这时候我们发现虽然可以去实现生产者消费者问题，但是我们想精准的唤醒执行，例如:**A执行---->B执行---->C执行---->A执行---->B执行---->C…**

我们依然可以通过Condition实现....

创建一个例子，依然通过Lock和Condition来实现:

通过Lock锁和Condition对象去实现一个生产者消费者问题的升级
    A 唤醒->B 唤醒-> C 唤醒 ->A
     */
    public class ProducerAndConsumer3 {
        
        public static void main(String[] args) {
        
            ProAndCon3 proAndCon3 = new ProAndCon3();
            new Thread(()->{
        
                for (int i = 0; i <5 ; i++) {
        
                    proAndCon3.printA();
                }
            },"A").start();
            new Thread(()->{
        
                for (int i = 0; i <5 ; i++) {
        
                    proAndCon3.printB();
                }
            },"B").start();
            new Thread(()->{
        
                for (int i = 0; i <5 ; i++) {
        
                    proAndCon3.printC();
                }
            },"C").start();
    
        }
    }
     class ProAndCon3{
        
        //创建Lock锁对象
        Lock lock=new ReentrantLock();
        //创建Condition对象
         Condition condition1=lock.newCondition();
         Condition condition2=lock.newCondition();
         Condition condition3=lock.newCondition();
    
         private  int num=1;
         //创建一个A执行方法
        public void printA(){
        
           lock.lock();
            try {
        
                while (num!=1){
        
                    //让condition1绑定到执行这个方法的线程上
                    condition1.await();//当num不等于1的时候，等待
                }
                System.out.println(Thread.currentThread().getName()+"->执行AAAAAAAAAAAAAAAAAAAAAAAAAA");
                num=2;
                condition2.signal();//唤醒绑定的线程2的condition对象
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            } finally {
        
                lock.unlock();
            }
        }
         //创建一个B执行方法
         public void printB(){
        
             lock.lock();
             try {
        
                 while (num!=2){
        
                     //让condition1绑定到执行这个方法的线程上
                     condition2.await();//当num不等于1的时候，等待
                 }
                 System.out.println(Thread.currentThread().getName()+"->执行BBBBBBBBBBBBBB");
                 num=3;
                 condition3.signal();//唤醒绑定的线程2的condition对象
             } catch (InterruptedException e) {
        
                 e.printStackTrace();
             } finally {
        
                 lock.unlock();
             }
         }
         //创建一个C执行方法
         public void printC(){
        
             lock.lock();
             try {
        
                 while (num!=3){
        
                     //让condition1绑定到执行这个方法的线程上
                     condition3.await();//当num不等于1的时候，等待
                 }
                 System.out.println(Thread.currentThread().getName()+"->执行CCCCCCCCCCCCCCCCCCCCCCCCCC");
                 num=1;
                 condition1.signal();//唤醒绑定的线程2的condition对象
             } catch (InterruptedException e) {
        
                 e.printStackTrace();
             } finally {
        
                 lock.unlock();
             }
         }
    }

**结果如下:**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTc5NjI5_size_16_color_FFFFFF_t_70 3]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTc5NjI5_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210103012907308.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTc5NjI5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTc5NjI5_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210103013738207.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTc5NjI5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTc5NjI5_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210103014145464.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTc5NjI5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTc5NjI5_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20210103014817590.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1OTc5NjI5,size_16,color_FFFFFF,t_70