JUC并发编程学习（四）-生产者与消费者

最新推荐文章于 2022-06-15 15:48:23 发布
最新推荐文章于 2022-06-15 15:48:23 发布
阅读量364 收藏 2
点赞数 1
分类专栏： JUC并发编程 文章标签： java 多线程 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36654629/article/details/105932461
版权

生产者和消费者

生产者消费者问题（Producer-consumer problem），也称有限缓冲问题（Bounded-bufferproblem），是一个多线程同步问题的经典案例。
简单说明，就是一个类用于生产，一个类用于消费。生产者生产一定的数据放入管存区，然后重复此操作，同时，消费者消费缓存区的数据。生产者和消费者之间必须保持同步 。要保证生产者不会在缓冲区满时放入数据，消费者也不会在缓冲区空时消耗数据。不够完善的解决方法容易出现死锁的情况，此时进程都在等待唤醒。

解决方法（思路）

采用某种机制保护生产者和消费者之间的同步。有较高的效率，并且易于实现，代码的可控制性较好，属于常用的模式。

在生产者和消费者之间建立一个管道。管道缓冲区不易控制，被传输数据对象不易于封装等，实用性不强。

解决问题的核心
   保证同一资源被多个线程并发访问时的完整性。常用的同步方法是采用信号或加锁机制，保证资源在任意时刻至多被一个线程访问。

Java能实现的几种方法

1.wait() / notify()方法—传统
2.await() / signal()方法—新版
3.BlockingQueue阻塞队列方法
4.信号量
5.管道

接下来重点介绍，1,2方法

生产者和消费者 synchroinzed 版 （wait/notify(）方法）

题目：现在两个线程，操作一个初始值为0的变量 一个线程 + 1， 一个线程 -1。判断什么时候+1，什么时候-1
交替10 次

package com.juc.study.lockdemo;


/**
* @ClassName:
* @PackageName: com.juc.study.lockdemo
* @author: youjp
* @create: 2020-04-14 15:25
* @description: TDOO 生产者消费模型：判断、干活、通知
* @Version: 1.0
*/
public class A {
    public static void main(String[] args) {


        Data data = new Data();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data.increment();
            }
        }, "A").start();


        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data.decrement();
            }
        }, "B").start();

    }


}


//属性、方法
class Data {


    private int num = 0;


    //+1操作
    public synchronized void increment() {
        //判断
        if (num > 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //干活
        num++;
        System.out.println(Thread.currentThread().getName() + "线程加操作\t" + num);
        //通知
        this.notify();
    }


    //-1 操作
    public synchronized void decrement() {


        //判断
        if (num == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //干活
        num--;
        System.out.println(Thread.currentThread().getName() + "线程减操作\t" + num);
        this.notify();
    }
}

控制台输出：在这里插入图片描述

使用了 synchronized关键字，当前只有2个操作是没存在什么问题。再加多加几个线程试试。

问题升级：防止虚假唤醒，4个线程，两个加，两个减

package com.juc.study.lockdemo;


/**
* @ClassName:
* @PackageName: com.juc.study.lockdemo
* @author: youjp
* @create: 2020-04-14 15:25
* @description: TDOO 生产者消费模型：判断、干活、通知
* @Version: 1.0
*/
public class A {
    public static void main(String[] args) {


        Data data = new Data();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data.increment();
            }
        }, "A").start();


        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data.decrement();
            }
        }, "B").start();


        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data.increment();
            }
        }, "C").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data.decrement();
            }
        }, "D").start();




    }


}


//属性、方法
class Data {


    private int num = 0;


    //+1操作
    public synchronized void increment() {
        //判断
        if (num > 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //干活
        num++;
        System.out.println(Thread.currentThread().getName() + "线程加操作\t" + num);
        //通知
        this.notify();
    }


    //-1 操作
    public synchronized void decrement() {


        //判断
        if (num == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //干活
        num--;
        System.out.println(Thread.currentThread().getName() + "线程减操作\t" + num);
        this.notify();
    }


}

然后发现出现了下面这样的问题。这是虚假唤醒的问题。

在这里插入图片描述

虚假唤醒:FalseNotify，线程竞争监视器导致的虚假唤醒。
虚假唤醒原因：A线程由wait被notify后，状态由WAITING变成BLOCKED状态，来竞争监视器，但是另外一个线程B也处于BLOCKED状态，它也会来竞争监视器，这是，CPU是没办法控制到底是谁先拿到监视器。
如果不是wait的A线程先拿到监视器,那当wait的A线程拿到监视器的时候，共享的值已经改变了。

查看了一下JDK文档，有做这样的说明在这里插入图片描述
原因是我们写的判断语句使用的是if，这样的写法引发了虚假唤醒的问题。改为while就没有这样的问题。

package com.juc.study.lockdemo;


/**
* @ClassName:
* @PackageName: com.juc.study.lockdemo
* @author: youjp
* @create: 2020-04-14 15:25
* @description: TDOO 生产者消费模型：判断、干活、通知
* @Version: 1.0
*/
public class A {
    public static void main(String[] args) {


        Data data = new Data();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data.increment();
            }
        }, "A").start();


        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data.decrement();
            }
        }, "B").start();


        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data.increment();
            }
        }, "C").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data.decrement();
            }
        }, "D").start();




    }


}


//属性、方法
class Data {


    private int num = 0;


    //+1操作
    public synchronized void increment() {
        //判断
       while (num > 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //干活
        num++;
        System.out.println(Thread.currentThread().getName() + "线程加操作\t" + num);
        //通知
        this.notify();
    }


    //-1 操作
    public synchronized void decrement() {


        //判断
       while (num == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //干活
        num--;
        System.out.println(Thread.currentThread().getName() + "线程减操作\t" + num);
        this.notify();
    }


}

生产者和消费者-新版JUC写法

查看jdk1.8文档，可看到 使用了Lock替换synchronized方法和语句的使用， Condition取代了对象监视器方法的使用。在这里插入图片描述
在这里插入图片描述
手写生产者消费者问题：100 分写法

package com.juc.study.lockdemo;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
* @ClassName:
* @PackageName: com.juc.study.lockdemo
* @author: youjp
* @create: 2020-04-14 15:25
* @description: TDOO 生产者消费模型：判断、干活、通知  //新版写法 
* @Version: 1.0
*/
public class B {
    public static void main(String[] args) {


        Data2 data = new Data2();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data.increment();
            }
        }, "A").start();


        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data.decrement();
            }
        }, "B").start();


        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data.increment();
            }
        }, "C").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data.decrement();
            }
        }, "D").start();

    }

}

//属性、方法
class Data2 {


    private int num = 0;


    //定义锁
    private Lock lock=new ReentrantLock();
    private Condition condition=lock.newCondition();


    //+1操作
    public  void increment() {

        //加锁
        lock.lock();

        try {
            //判断
            while (num > 0) {
                 condition.await(); //等待
             }
            //干活
            num++;
            System.out.println(Thread.currentThread().getName() + "线程加操作\t" + num);
            condition.signalAll();//通知


        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //解锁
            lock.unlock();
        }
    }


    //-1 操作
    public  void decrement() {


        //加锁
        lock.lock();
        try {
            //判断
            while (num == 0) {
                condition.await();//等待
             }
            //干活
            num--;
            System.out.println(Thread.currentThread().getName() + "线程减操作\t" + num);
            condition.signalAll();//通知
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();//    解锁
        }
    }
}

以上4个进程，唤醒是随机的，即进程的执行时随机的，不是有序进行的，那怎么能让进程有序执行呢。接下来我们讨论进程间如何精确通知访问。

控制线程精确通知顺序访问 Condition

Lock提供了一个接口Condition,通过Lock类对象获取Condition实现类对象。通过Condition，可以指定唤醒哪个进程。

condition最大的特点是可以实现精确顺序通知线程的使用.
一个Condition实例本质上绑定到一个锁。 要获得特定Condition实例的Condition实例，请使用其newCondition()方法。

例如，假设我们有一个有限的缓冲区，它支持put和take方法。 如果在一个空的缓冲区尝试一个take ，则线程将阻塞直到一个项目可用; 如果put试图在一个完整的缓冲区，那么线程将阻塞，直到空间变得可用。 我们希望在单独的等待集中等待put线程和take线程，以便我们可以在缓冲区中的项目或空间可用的时候使用仅通知单个线程的优化。 这可以使用两个Condition实例来实现。

  class BoundedBuffer {
   final Lock lock = new ReentrantLock();
   final Condition notFull  = lock.newCondition(); 
   final Condition notEmpty = lock.newCondition(); 

   final Object[] items = new Object[100];
   int putptr, takeptr, count;

   public void put(Object x) throws InterruptedException {
     lock.lock(); try {
       while (count == items.length)
         notFull.await();
       items[putptr] = x;
       if (++putptr == items.length) putptr = 0;
       ++count;
       notEmpty.signal();
     } finally { lock.unlock(); }
   }

   public Object take() throws InterruptedException {
     lock.lock(); try {
       while (count == 0)
         notEmpty.await();
       Object x = items[takeptr];
       if (++takeptr == items.length) takeptr = 0;
       --count;
       notFull.signal();
       return x;
     } finally { lock.unlock(); }
   }
 }

实例
使用num进行数字变换，1,2,3分别代表A,B,C。 当num=1时，A打印3次，打印完通知B线程打印10次，B线程打印结束通知C线程。

package com.juc.study.lockdemo;


import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


/**
* @ClassName:
* @PackageName: com.juc.study.lockdemo
* @author: youjp
* @create: 2020-04-15 14:19
* @description:    TODO 精确线程调用A->B->C->A
* @Version: 1.0
*/
public class C {
    public static void main(String[] args) {
        Data3 da = new Data3();
        new Thread(() -> {
            for (int i = 0; i <10 ; i++) {
                da.print3();
            }
        }, "A").start();


        new Thread(() -> {
            for (int i = 0; i <10 ; i++) {
                da.print10();
            }
        }, "B").start();


        new Thread(() -> {
            for (int i = 0; i <10 ; i++) {
                da.print5();
            }
        }, "C").start();
    }
}


class Data3 {


    private int num = 1;  //1:A  2:B 3:C ,1表示A,2表示B...
    //锁
    private Lock lock = new ReentrantLock();
    private Condition conditionA = lock.newCondition(); 3个判断，交替执行 A--B-- C--A
    private Condition conditionB = lock.newCondition();
    private Condition conditionC = lock.newCondition();




    /**
     * A :打印3次后，通知B
     */
    public void print3() {
        lock.lock();
        //获取锁
        try {
            while (num != 1) {
                conditionA.await();
            }
            //干活
            for (int i = 0; i < 3; i++) {
                System.out.println(Thread.currentThread().getName() + "\t打印次数：" + i);
            }
            num = 2;
            //第一个线程通知第2个线程，第2个通知第3个。。
            conditionB.signal();


        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();//解锁
        }
    }




    /**
     * B :打印10次后，通知C
     */
    public void print10() {
        //获取锁
        lock.lock();
        try {
            while (num != 2) {
                conditionB.await();//等待
            }
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "\t打印次数：" + i);
            }
            num = 3;
            conditionC.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }


    /**
     * C:打印5次后，通知A
     */
    public void print5() {
        lock.lock();


        try {
            while (num != 3) {
                conditionC.await();
            }
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + "\t打印次数：" + i);
            }
            num = 1;
            conditionA.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

打印结果：
在这里插入图片描述
其他实现方法参考：
https://blog.csdn.net/zgj12138/article/details/74012263?depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-1&utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-1

有兴趣的老爷，可以关注我的公众号【一起收破烂】，回复【006】获取2021最新java面试资料以及简历模型120套哦~
在这里插入图片描述

收破烂的小熊猫~
关注
专栏目录
RocketMQ（四）：生产者消费者实践
qq_28834355的博客
02-01 321
文章目录准备工作同步生产异步生产有序消费并发消费 准备工作 先用命令创建Topic，执行成功后默认会创建8个队列 sh mqadmin updateTopic -b localhost:10911 -n localhost:9876 -t TopicTest Producer发送消息时，Topic不存在也会自动创建，但是一般不建议这样做。 同步生产 发送消息时，等待返回结果才发送下一条。速度相对慢一点，消息不易丢失。 public class SyncProducer { public stati
JUC并发编程学习笔记
Melekh_的博客
02-26 520
一、什么是JUC JUC指的是：Java里的三个包 java.util.concurrent java.util.concurrent.atomic：原子性 java.util.concurrent.locks：lock锁 二、线程和进程 1.进程 程序执行的一次过程，一个进程包含一个或多个线程。进程是资源分配的单位。 2.线程 可以指程序执行过程中，负责实现某个功能的单位。线程是CPU调度和执行的单位。 3.并发 同一时刻，多个线程交替执行。（一个CPU交替执行线程） 4.并行 同一时
JUC并发编程（四）-生产者和消费者
二总的猫
02-26 326
4、生产者和消费者 线程间默认是无法通信的，所以需要调度线程。 Producer And Consumer，以下代码中简称Pac。 4.1. 生产者消费者编码模型 1、判断 2、干活 3、通知 4.2. 生产者和消费者- synchroinzed 版 4.2.1. synchroinzed 实现的生产者与消费者 package com.interview.concurrent.lock.pro...
synchroinzed
一只超级迷茫的猿
06-03 267
synchroinzed 假如有两个线程ThreadA/ThreadB 只有ThreadA去访问（大部分情况是属于这种） ->引入了偏向锁 ThreadA的ThreadId、每次线程A进来判断ThreadId是否一样，在判断偏向锁标记是否为1 ThreadA和ThreadB交替访问->轻量级锁->自旋 多个线程同时访问 ->阻塞。（挂起，等待获得锁） 在我们程序中我们怎么知道当前上面3种场景是哪种情况呢，只能通过升级锁的方式来达到，升级锁的顺序为： 偏向锁 -&g
wait&signal---生产者和消费者问题
chunjiekid的博客
03-15 2247
https://www.jianshu.com/p/b16296e9ac85
生产者消费者问题
惜朝歌的博客
05-07 9535
生产者消费者问题
JUC生产者和消费者三种实现方式
好想去看海
09-09 219
一、wait和notify： package threadcoreknowledge.threadobjectclasscommonmethods; import java.util.ArrayList; import java.util.Date; import java.util.LinkedList; import java.util.List; /** * 描述： 用wait/notify来实现生产者消费者模式 */ public class ProducerConsumerMode
JUC并发编程学习笔记(硅谷)
最新发布
07-23
"JUC并发编程学习笔记(硅谷)"很可能包含了关于Java并发工具集（Java Util Concurrency, JUC）的深入理解和实战经验。JUC是Java标准库提供的一套强大的并发处理工具，它极大地简化了多线程编程，提高了程序的可读性...
JUC并发编程《Java-2021面试谈资系列》
zjdzka的博客
03-25 3177
JUC并发编程一、什么是JUC二、线程和进程三、Lock锁(重点)区别：四、生产者消费者五、8锁现象问题1，2问题3，4问题5，6问题7，8总结六、集合不安全CopyOnWriteArrayListCopyOnWriteSetConcurrentHashMap七、Callable八、常用辅助类CountDownLatchCyclicBarrierSemaphore九、读写锁十、阻塞队列方式一方式二方式三方式四同步队列十一、JMM十二、Volatile十三、单例模式十四、CAS十五、原子引用十六、各种锁的理解
基于《狂神说Java》JUC并发编程--学习笔记
wudidahuanggua的博客
06-15 862
本笔记仅做学习与复习使用，不存在刻意抄袭。给各位学友强烈推荐《遇见狂神说》他的整套Java学习路线使我获益匪浅！！!点击跳转至遇见狂神说哔哩哔哩首页如果你也是狂神的小迷弟，可以加我好友一起探讨学习。 ...
java并发编程艺术源码-ArtConcurrentBook:JAVA并发编程的艺术
05-25
- 生产者消费者模型：`BlockingQueue`可以作为生产者和消费者的交界，实现线程间的数据传递。 - 线程安全的发布和订阅：`Phaser`和`CyclicBarrier`等可以用于实现多线程间的同步协调。 8. **并发异常处理** - ...
JUC并发编程学习（一）-什么是JUC
收破烂的小熊猫
04-16 6609
什么是JUC? 查看了一下jdk1.8的文档，可以看到packge下的java.util.concurrent包 什么是JUC：java.util.concurrent包名的简写,是关于并发编程的API。 与JUC相关的有三个包：java.util.concurrent、java.util.concurrent.atomic、java.util.concurrent.locks。 也查看了一些前...
JUC并发编程学习（十四）-任务拆分ForkJoin详解
收破烂的小熊猫
06-14 615
分而治之思想 在古代，皇帝要想办成一件事肯定不会自己亲自去动手，而是把任务细分发给下面的大臣，下面的大臣也懒呀，于是把任务继续分成几个部分，继续下发，于是到了最后最终负责的人就完成了一个小功能。上面的领导再把这些结果一层一层汇总，最终返回给皇帝。这就是分而治之的思想。 什么是ForkJoin 从JDK1.7开始，Java提供ForkJoin框架用于并行执行任务，它的思想就是将一个大任务分割成若干小任务，最终汇总每个小任务的结果得到这个大任务的结果。简单的理解，ForkJoin是一个可对任务进行拆分，分而.
JUC并发编程学习（十）-阻塞队列、同步队列
收破烂的小熊猫
05-27 492
BlockingQueue 队列的特点：先进先出 阻塞队列在拥有队列的基本特征的同时，还额外支持两个附加操作。这两个附加的操作支持阻塞的插入和移除方法。 阻塞插入 队列插入元素时，当队列空间已经使用满了，不得不阻塞 阻塞移除 队列中有元素，在取元素时可以移除，队列为空时，阻塞不能取出，等待队列中有新的元素才能取出。 阻塞队列常用于生产者和消费者的场景，生产者是向队列里添加元素的线程，消费者是从队列里取元素的线程。阻塞队列就是生产者用来存放元素、消费者用来获取元素的容器。 接口架构图
JUC并发编程学习（十五）-异步回调之CompletableFuture
收破烂的小熊猫
06-21 452
Future Future接口是Java多线程Future模式的实现，在java.util.concurrent包中，可以用来进行异步计算。 Future模式是多线程中一种常用的模式。可以理解为：我有一个任务，把它交给Future去完成。在这期间我可以去做自己想干的事情，过段时间后，我可以直接去Future那提取结果。 Future的接口主要有五个方法。 public interface Future<V> { boolean cancel(boolean mayInterruptIf
JUC并发编程学习（十 一）-ThreadPoolExecutor线程池的学习
收破烂的小熊猫
05-30 382
线程池的核心知识就是：三大方法、7个参数、拒绝策略、优化配置 线程池原理 程序运行的本质是，占用系统资源，CPU/磁盘网络使用。我们希望可以高效的使用资源！池化技术就是不断的演进出来的。 池化技术 简单的说，池化技术就是提前准备一些资源，以供使用。 线程的创建和销毁，以及数据库的连接断开都十分浪费资源。 只有是“池”，就会设计到两个常量： minSize:最小容量 maxSize最大容量 这些都是为了弹性访问，保证系统运行的效率。 举一个常见的例子。去银行取钱，一般来说银行会固定开放2个窗口供人.
JUC并发编程学习（七）-Callable学习
收破烂的小熊猫
05-13 375
Callable 线程的创建方式主要有Thread、Runnable、Callable这几种，那么他们的主要区别是： 1.是否返回值？ Runnable无返回值，而Callable有返回值。 2.是否跑出异常？ Runnable无异常，Callable有异常 3.方法不同？ Runnable 运行的方法是run，Callable运行的方法是call 为了学习Callable，首先我们来写一个简单的线程，代码如下： package com.jp.call; import java.util.concur
JUC并发编程学习（五）-8锁现象
收破烂的小熊猫
05-06 369
以下名词解释： 顺序执行：先调用的先执行； 随机执行：没有规律，与计算机硬件资源有关，哪个线程先得到资源就先执行，各个线程之间互不干扰 将从以下8个方面介绍锁现象1. 多个线程使用同一把锁-顺序执行2. 多个线程使用同一把锁，其中某个线程里面还有阻塞-顺序先执行3. 多个线程有锁与没锁-随机执行4.多个线程使用多把锁-随机执行5. Class锁：多个线程使用一个对象-顺序执行6. Class锁...
"Java-JUC-多线程 进阶：遇见狂神说的JUC并发编程进阶版概要
这是一种常见的并发编程模式，可以实现一个生产者线程和一个消费者线程之间的数据交互。通过使用锁和条件变量，生产者线程可以将数据放入队列，而消费者线程可以从队列中取出数据。这个模式可以很好地解决多线程间的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

收破烂的小熊猫~

你的鼓励将是我创造最大的东西~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值