【多线程】生产者消费者传统版和阻塞队列版

最新推荐文章于 2023-01-05 09:00:00 发布
最新推荐文章于 2023-01-05 09:00:00 发布
阅读量238 收藏
点赞数 1
分类专栏： 多线程
原文链接：https://blog.csdn.net/Delicious_Life/article/details/106450803
版权
前言

等待与唤醒机制其实就是经典的生产者与消费者问题

我们知道，生产者要想和消费者作用在一件产品上，必须要用到锁机制。通过锁机制保证一个产品同一时间只有一个角色在执行。

下面将分别使用Synchronized和Lock锁解决生产者和消费者的问题。

1Synchronized版
/**
 * 线程之间的通信问题：生产者与消费者问题！
 * A和B操作同一个变量，线程交替执行，num=0
 * A num+1
 * B num-1
 */
public class A {
    public static void main(String[] args) {
        Data data = new Data();
 
        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
 
        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
}
 
//判断等待、业务、通知
class Data{  //数字资源类
    private int number = 0;
 
    //+1
    public synchronized void increment() throws InterruptedException {
        if (number!=0){
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，+1完毕了
        this.notifyAll();
    }
 
    //-1
    public synchronized void decrement() throws InterruptedException {
        if (number==0){
            //进入等待状态
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，-1完毕了
        this.notifyAll();
    }
 
}

可以看到线程有序执行没有问题。

在这里插入图片描述

2、虚假唤醒

当我们把线程数增加到4个时，2个增操作、2个减操作，代码会报错。
在这里插入图片描述

原因是你的增减方法中存在if条件判断，当使用if判断时，只要有一个条件满足，所有被满足的线程都会被唤醒，也就是说一次会唤醒2个+或2个-。解决此问题的办法就是把if判断换成while循环。参考jdk手册
在这里插入图片描述

3、Lock版

Lock锁是JUC提供的一个接口。我们在使用时一般用它的实现类ReetrantLock(可重入锁)

在synchronized中我们使用wait和notify进行等待唤醒操作，wait、notify存在于Object类中。而Lock提供的await、signal属于JUC包，Juc为我们提供了condition.await和condition.signal来进行等待与唤醒操作~
在这里插入图片描述

/**
 * 线程之间的通信问题：生产者与消费者问题！
 * A和B操作同一个变量，线程交替执行，num=0
 * A num+1
 * B num-1
 */
public class B {
    public static void main(String[] args) {
        Data2 data2 = new Data2();
 
        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                try {
                    data2.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
 
        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                try {
                    data2.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
 
        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                try {
                    data2.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
 
        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                try {
                    data2.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}
 
//判断等待、业务、通知
class Data2{  //数字资源类
    private int number = 0;
 
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
 
    //condition.await();等待
    //condition.signalAll();唤醒
    //+1
    public  void increment() throws InterruptedException {
        lock.lock();
        try {
            while (number!=0){
                //等待
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //通知其他线程，+1完毕了
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }
 
    //-1
    public  void decrement() throws InterruptedException {
        lock.lock();
        try {
            while (number==0){
                //进入等待状态
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //通知其他线程，-1完毕了
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
 
}

在这里插入图片描述

4、Condition精准通知与唤醒线程

使用Lock锁之后，我们同样实现了等待与唤醒机制，但是ABCD执行是没有顺序的，如何让ABCD顺序执行呢？Condition~

其实原理非常简单，我们设置线程休眠是按顺序唤醒即可A==>B==>C

/**
 * A执行完调用B，B执行完调用C，C执行完调用A
 */
public class C {
    public static void main(String[] args) {
        Data3 data3 = new Data3();
 
        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                data3.printA();
            }
        },"A").start();
 
        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                data3.printB();
            }
        },"B").start();
 
        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                data3.printC();
            }
        },"C").start();
    }
}
 
class Data3{
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int number = 1;         //1是A，2是B，3是C
 
    public void printA(){
        lock.lock();
        try {
            //判断、执行、通知
            while (number !=1){
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"==>AAAA");
            number = 2;
            condition2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
 
    public void printB(){
        lock.lock();
        try {
            //判断、执行、通知
            while (number !=2){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"==>BBBB");
            number = 3;
            condition3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
 
    public void printC(){
        lock.lock();
        try {
            //判断、执行、通知
            while (number !=3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"==>CCCC");
            number = 1;
            condition1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

在这里插入图片描述

5、阻塞队列版

无论是lock还是sychronized都需要我们手动控制等待和唤醒，使用BlockingQueue版解决生产者消费者问题可以达到自动控制等待、唤醒与停止。

class MyResource {
    private volatile boolean FLAG = true; //默认开启，进行生产+消费
    private AtomicInteger atomicInteger = new AtomicInteger();

    BlockingQueue<String> blockingQueue = null;

    public MyResource(BlockingQueue<String> blockingQueue) {
        this.blockingQueue = blockingQueue;
        System.out.println(blockingQueue.getClass().getName());
    }

    public void myProdu() throws Exception {
        String data = null;
        boolean retValue;
        while (FLAG) {
            data = atomicInteger.incrementAndGet() + "";
            retValue = blockingQueue.offer(data, 2L, TimeUnit.SECONDS);
            if (retValue) {
                System.out.println(Thread.currentThread().getName() + "\t 插入队列" + data + "成功");
            } else {
                System.out.println(Thread.currentThread().getName() + "\t 插入队列" + data + "失败");
            }
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() + "\t 大老板叫停了，表示FLAG=false，生产动作结束");
    }

    public void myConsumer() throws Exception {
        String result = null;
        while (FLAG) {
            result = blockingQueue.poll(2, TimeUnit.SECONDS);
            if (null == result || result.equalsIgnoreCase("")) {
                FLAG = false;
                System.out.println(Thread.currentThread().getName() + "\t 超过2秒钟没有取到蛋糕，消费退出");
                System.out.println();
                System.out.println();
                return;
            }
            System.out.println(Thread.currentThread().getName() + "\t 消费队列蛋糕" + result + "成功");
        }
    }

    public void stop()throws Exception{
        this.FLAG = false;
    }
}


public class ProdConsumer_BlockQueueDemo {
    public static void main(String[] args) throws Exception {
        MyResource myResource = new MyResource(new ArrayBlockingQueue<>(10));

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t 生产线程启动");
            try {
                myResource.myProdu();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "Prod").start();

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t 消费线程启动");
            System.out.println();
            System.out.println();
            try {
                myResource.myConsumer();
                System.out.println();
                System.out.println();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "Consumer").start();

        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println();
        System.out.println();
        System.out.println();

        System.out.println("5秒钟时间到，大老板main线程叫停，活动结束");

        myResource.stop();
    }
}

在这里插入图片描述

光哥_帅
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
多线程--阻塞队列
withu
06-13 478
阻塞队列 阻塞队列是并发编程的一个重要基础组件.帮助我们实现"生产者-消费者模型" 这是一种典型的处理并发编程的模式 阻塞队列就可以作为生产者-消费者模型的交易场所 重要的特点: 如果生产者生产的较快,生产者就要等待,一直等到消费者又消费了一些数据 也就是交易场所上有了空位才能进行生产 如果消费者消费的过快,那么消费者就要等待,一直等到生产者生产了 新的元素,那么消费者才能继续消费 阻塞队列的特点也是如此 如果入队列操作太快,队列满了,继续入队列,就会阻塞,一直阻塞到有其他线程去消费队列了,才能继续入
用阻塞队列实现生产者消费者模式二(多线程消费)
Neo.Yang的专栏
08-16 606
在性能优化时使用生产者消费者模式，很多时候是为了提升数据的消费处理能力。采用多个消费者线程并发处理数据，能起到性能提升的效果。 下文在“阻塞队列实现生产者消费者模式一(单线程消费)” 的基础上描述。 一、在接口层增加测试接口 package com.elon.rest; import com.elon.service.ProConsService; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperation;
多线程案例-阻塞式队列
最新发布
chenchenchencl的博客
01-05 1349
多线程案例-阻塞式队列
Java中的线程通信——生产者与消费者问题
我能在河边钓一整天的鱼
05-31 220
目录 前言 Synchronized 虚假唤醒 Lock Condition的精准通知与唤醒线程 前言 等待与唤醒机制其实就是经典的生产者与消费者问题 我们知道，生产者要想和消费者作用在一件产品上，必须要用到锁机制。通过锁机制保证一个产品同一时间只有一个角色在执行。 下面将分别使用Synchronized和Lock锁解决生产者和消费者的问题。 Synchronized notify唤醒单个线程、notifyAll唤醒所有等待的线程。注意：wai...
浅谈多线程生产者和消费者问题（阻塞队列实现等待唤醒机制）
m0_66884848的博客
04-24 302
一、ArrayBlockingQueue概述 ArrayBlockingQueue的底层是一个有界数组，它实现了BlockingQueue接口。而在BlockingQueue方法中有两个非常核心的方法： void put(E e):将参数放入队列中，如果放不进去会阻塞。 E take():取出第一个数据，取不到会阻塞 二、代码演示： take进入阻塞的情况： ArrayBlockingQueue<String> list = new...
Java多线程 BlockingQueue实现生产者消费者模型详解
08-25
在Java中，我们可以使用BlockingQueue来实现生产者消费者模型，BlockingQueue是Queue的子类，它提供了一个线程安全的队列，可以用于生产者和消费者之间的数据传输。 BlockingQueue的实现类有多种，常见的有...
wpf窗体多线程实现生产者消费者模型
10-31
在多线程环境下，生产者和消费者通常运行在不同的线程上，以避免因相互等待而产生的阻塞。为了协调这两者的操作，我们需要一种机制来同步对共享资源（如队列）的访问。 在C#中，`System.Threading.Semaphore`类提供...
12.2 Qt5多线程：使用信号量实现生产者和消费者
02-15
6. **线程间的通信**：在生产者和消费者之间，可能还需要额外的信号和槽（signal and slot）来协调他们的操作，比如当缓冲区满时通知生产者停止生产，或者当缓冲区空时通知消费者暂停消费。 通过以上步骤，我们可以...
java—多线程的通信、生产者与消费者模式
12-21
理解Java多线程通信和生产者-消费者模式对于编写高效并发程序至关重要。使用`synchronized`关键字和`wait()`, `notify()`, `notifyAll()`来控制线程间的协作，可以避免数据竞争和死锁等问题。同时，掌握线程的状态和...
C#多线程学习之(三)生产者和消费者用法分析
09-03
在多线程环境中，生产者和消费者模型是一种常见的设计模式，用于处理共享资源的访问。本篇将深入探讨C#中的生产者和消费者用法，以及如何解决线程冲突和资源分配问题。 生产者和消费者模型涉及到两个角色：生产者...
生产者/消费者模式 阻塞队列 LinkedBlockingQueue
06-08
NULL 博文链接：https://xiongjiajia.iteye.com/blog/2325943
System V共享内存与信号量综合应用之生产者与消费者问题解决
05-27
用System V共享内存与信号量综合应用之生产者与消费者问题解决的相关代码,几乎每句代码都有注释,方便阅读.
线程
Outsider_in的博客
12-10 314
并行与并发 并发：指的是两个或者多个事件(任务)在同一时间段内发生的。 并行：指的是两个或者多个事件(任务)在同一时刻发生(同时发生)。 图解如下： 线程与进程 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个线程；进程也是程序的一次执行过程，是系统 运行程序的基本单位；系统运行一个程序就是一个进程从创建、运行到消亡的过程。 线程：线程是进程中的一个执行单元，负责当前进程中程序的运行，一个程序中至少有一个线程。一个进程可以有多个线程，这个应用程序也可以称之
生产者/消费者模式(阻塞队列) 一个经典的并发模型
热门推荐
不能说的秘密的博客
05-30 1万+
生产消费者模式也是关于线程阻塞的问题，生产消费者模式是通过观察者模式来实现的。之前在编写一个通讯软件的时候用到了这种模式，通过维护一个BlockingQueue来完成Socket的消息发送
线程池、多线程、单线程性能对比及原因分析
weixin_46539949的博客
11-04 1460
测评一下使用多线程、线程池和单线程情况下的效率 public class Main{ public static void main(String[] args) throws InterruptedException { List<Integer> l = new LinkedList<>(); ThreadPoolExecutor tp = (ThreadPoolExecutor) Executors.newFixedThreadPoo...
死锁机制以及生产者与消费者模式
qq_34780061的博客
09-12 1507
    java之所以能够一直矗立在各种编程语言之前，与它的多线程技术是密不可分的！   1.我们在使用多线程技术时，除了要保证他的效率，更要确保安全性，java的多线程技术为了确保其安全引入了锁（synchronized）的概念，给程序的安全带来了极大的保证  2.synchronized（锁）我简单的分为代码块锁和方法锁     这两个锁执行的内容是一样的，但是他们的锁对象不一样，代码...
BlockingQueue（阻塞队列）详解
weixin_30478923的博客
04-24 2774
注意：该随笔内容完全引自http://wsmajunfeng.iteye.com/blog/1629354，写的很好，非常感谢，复制过来算是个积累，怕以后找不到。 一. 前言 　　在新增的Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了Blo...
生产者消费者模型---阻塞队列实现（BlockingQueue）
qq_41864967的博客
04-17 131
import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; public class Solution { public static void main(String[] args) { BlockingQueue<Integer> queue ...
Java多线程解决生产者-消费者问题
在多线程编程中，生产者-消费者问题是典型的同步与互斥问题，涉及如何协调生产者和消费者对共享数据的访问。可能遇到的问题包括生产者过快导致消费者漏取数据，或者消费者过快造成重复处理数据。解决这些问题的关键...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值