常用的阻塞队列用法以及原理

最新推荐文章于 2023-07-12 09:27:31 发布
最新推荐文章于 2023-07-12 09:27:31 发布
阅读量829 收藏 2
点赞数 1
分类专栏： JUC 并发编程 文章标签： 队列 queue 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Avril___/article/details/106171421
版权

理论：
在这里插入图片描述
阻塞队列举例：
火锅店欢迎阻塞
去银行排队不得不阻塞

什么是阻塞队列
在这里插入图片描述
在这里插入图片描述
为什么用阻塞队列
在这里插入图片描述

架构
继承关系
collection—>queue->七个阻塞队列接口
在这里插入图片描述
三个红色是重点一个粉色需注意，最后一个注意拼写（deque）
虽然有界但是是21亿的长度，接近无界（21亿）
synchronousQueue是生产一个，没消费不会再生产，故为不储存（贝克汉姆球鞋）

所有用法API
在这里插入图片描述

异常用法
element()是检查队头元素是谁

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class BlockingQueueDemo {
    public static void main(String[] args) {
        BlockingQueue<Object> queue = new ArrayBlockingQueue<>(3);

        System.out.println(queue.add("1"));
        System.out.println(queue.add("2"));
        System.out.println(queue.add("3"));
        //System.out.println(queue.add("6"));

        System.out.println(queue.element());

        System.out.println(queue.remove());
        System.out.println(queue.remove());
        System.out.println(queue.remove());
        //System.out.println(queue.remove());
    }
}

特殊值用法（也就是布尔值）
peek()是查看队列顶端元素
offer添加超过队长返回false
pull拿值无值返回null

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

public class BlockingQueueDemo2 {
    public static void main(String[] args) {
        BlockingQueue<Object> queue = new ArrayBlockingQueue<>(3);

        try {
            System.out.println(queue.offer(1,1, TimeUnit.SECONDS));
            System.out.println(queue.offer(2,1, TimeUnit.SECONDS));
            System.out.println(queue.offer(3,1, TimeUnit.SECONDS));
            System.out.println(queue.offer(4,1, TimeUnit.SECONDS));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println();
        System.out.println(queue.peek());
        System.out.println();

        try {
            System.out.println(queue.poll(1,TimeUnit.SECONDS));
            System.out.println(queue.poll(1,TimeUnit.SECONDS));
            System.out.println(queue.poll(1,TimeUnit.SECONDS));
            System.out.println(queue.poll(1,TimeUnit.SECONDS));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

阻塞
不够加入或者取不到值就一直阻塞线程

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

public class BlockingQueueDemo3 {
    public static void main(String[] args) {
        BlockingQueue<Object> queue = new ArrayBlockingQueue<>(3);
        try {
            queue.put(1);
            queue.put(2);
            queue.put(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        try {
            System.out.println(queue.take());
            System.out.println(queue.take());
            System.out.println(queue.take());
            //System.out.println(queue.take());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

超时
队列超了等几秒，如果还超就返回false
队列取不到值了就等几秒，如果还取不到值就返回null

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

public class BlockingQueueDemo3 {
    public static void main(String[] args) {
        BlockingQueue<Object> queue = new ArrayBlockingQueue<>(3);
        try {
            System.out.println(queue.offer(1, 1, TimeUnit.SECONDS));
            System.out.println(queue.offer(1, 1, TimeUnit.SECONDS));
            System.out.println(queue.offer(1, 1, TimeUnit.SECONDS));
            System.out.println(queue.offer(1, 1, TimeUnit.SECONDS));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        try {
            System.out.println(queue.poll(2,TimeUnit.SECONDS));
            System.out.println(queue.poll(2,TimeUnit.SECONDS));
            System.out.println(queue.poll(2,TimeUnit.SECONDS));
            System.out.println(queue.poll(2,TimeUnit.SECONDS));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

钱多事少离家近，别人加班你加薪

synchronousQueue的理论
在这里插入图片描述

import java.sql.Time;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

public class SynchronousQueueDemo {
    public static void main(String[] args) {
        BlockingQueue<Object> queue = new SynchronousQueue<>();

        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+"put1");
                queue.put(1);
                System.out.println(Thread.currentThread().getName()+"put2");
                queue.put(2);
                System.out.println(Thread.currentThread().getName()+"put3");
                queue.put(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"AAA").start();

        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"get1");
                System.out.println(queue.take());

                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"get2");
                System.out.println(queue.take());

                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"get3");
                System.out.println(queue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"BBB").start();
    }
}

同步队列不存储元素，第一个put完必须等take过后才打印，put2，而不是直接打印

只能有一个在队列里面

所有脑图
在这里插入图片描述

生产者消费者模式

高内聚低耦合的情况下线程操纵资源类
判断干活唤醒通知
while严防多线程并发状态下的虚假唤醒
在这里插入图片描述

多线程判断要用while防止虚假唤醒
在这里插入图片描述
传统版的生产者消费者模式代码

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

class shareDate {
    private int number = 0;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void increment() {
        lock.lock();
        try {
            //判断
            while (number != 0) {
                //不能生产
                condition.await();
            }
            //生产
            number++;
            System.out.println(Thread.currentThread().getName() + "线程 \t" +number+ "生产");
            //唤醒
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    public void decrement() {
        lock.lock();
        try {
            //判断
            while (number == 0) {
                //不能消费
                condition.await();
            }
            //消费
            number--;
            System.out.println(Thread.currentThread().getName() + "线程 \t" +number+ "消费");
            //唤醒
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

}

public class ProductConsumerDemo {
    public static void main(String[] args) {
        shareDate shareDate = new shareDate();
        new Thread(()->{
            for (int i = 1; i <= 5 ; i++) {
                shareDate.increment();
            }
        },"AAA").start();

        new Thread(()->{
            for (int i = 1; i <= 5 ; i++) {
                shareDate.decrement();
            }
        },"BBB").start();

        new Thread(()->{
            for (int i = 1; i <= 5 ; i++) {
                shareDate.increment();
            }
        },"CCC").start();

        new Thread(()->{
            for (int i = 1; i <= 5 ; i++) {
                shareDate.decrement();
            }
        },"DDD").start();
    }
}

sync和lock的区别
在这里插入图片描述
sync两次退出，第一次正常退出第二次异常退出
在这里插入图片描述
之前敲过
在这里插入图片描述
代码

package juc;

import sun.awt.windows.ThemeReader;

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

class ShareResource{

    private int flag = 1;

    private ReentrantLock lock = new ReentrantLock();

    private Condition condition1 = lock.newCondition();

    private Condition condition2 = lock.newCondition();

    private Condition condition3 = lock.newCondition();

    //ctrl+alt+t是try catch

    public void print5(int totalLoop){
        lock.lock();
        try {
            //1.判断
            while (flag != 1){
                condition1.await();
            }
            //干活

            for (int i = 1;i <= 5; i++) {
                System.out.println("线程名字:"+Thread.currentThread().getName()+"\t次数:"+i+"\t轮数:"+totalLoop);
            }

            //唤醒+通知
            flag = 2;
            condition2.signal();

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

    public void print10(int totalLoop){
        lock.lock();
        try {
            //1.判断
            while (flag != 2){
                condition2.await();
            }
            //干活

            for (int i = 1;i <= 10; i++) {
                System.out.println("线程名字:"+Thread.currentThread().getName()+"\t次数:"+i+"\t轮数:"+totalLoop);
            }

            //唤醒+通知
            flag = 3;
            condition3.signal();

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

    public void print15(int totalLoop){
        lock.lock();
        try {
            //1.判断
            while (flag != 3){
                condition3.await();
            }
            //干活

            for (int i = 1;i <= 15; i++) {
                System.out.println("线程名字:"+Thread.currentThread().getName()+"\t次数:"+i+"\t轮数:"+totalLoop);
            }

            //唤醒+通知
            flag = 1;
            condition1.signal();

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



}

public class ConditionLockDemo {
    public static void main(String[] args) {

        ShareResource sr = new ShareResource();

        new Thread(()->{
            for(int i = 1 ; i<=10 ; i++){
                sr.print5(i);
            }
        },"A").start();

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

        new Thread(()->{
            for(int i = 1 ; i<=10 ; i++){
                sr.print15(i);
            }
        },"C").start();
    }
}

代码编写时应注意：
通顺，适配，通用
传借口不允许传具体的类
写往抽象写，查往仔细落地查
永远传参传接口

阻塞队列版的生产者消费者模式代码

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;


class ProductConsumer {
    private volatile boolean FLAG = true;
    private AtomicInteger atomicInteger = new AtomicInteger();
    private BlockingQueue<String> blockingQueue = null;

    public ProductConsumer(BlockingQueue<String> blockingQueue) {
        this.blockingQueue = blockingQueue;
    }

    public void increment() throws Exception {
        String date = null;
        boolean retValue;
        while (FLAG) {
            date = atomicInteger.incrementAndGet() + "";
            retValue = blockingQueue.offer(date, 2L, TimeUnit.SECONDS);

            if (retValue) {
                System.out.println(Thread.currentThread().getName() + "\t" + date + "生产一个蛋糕");
            } else {
                System.out.println(Thread.currentThread().getName() + "\t" + date + "生产一个失败");
            }
            TimeUnit.SECONDS.sleep(1);
        }
        System.out.println(Thread.currentThread().getName()+"boss暂停不生产了");
    }

    public void decrement() throws Exception {
        String result = null;
        while (FLAG) {
            result = blockingQueue.poll(2L, TimeUnit.SECONDS);
            if(null == result || result.equalsIgnoreCase("")){
                FLAG = false;
                System.out.println(Thread.currentThread().getName()+"超过两秒没有取出蛋糕暂停");
                return;
            }
            System.out.println(Thread.currentThread().getName()+"消费蛋糕成功");
        }
    }

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

public class ProductConsumerBlockingQueue {
    public static void main(String[] args){
        ProductConsumer productConsumer = new ProductConsumer(new ArrayBlockingQueue<>(10));

        new Thread(()->{
            try {
                System.out.println("生产线程启动");
                for (int i = 1; i <= 5 ; i++) {
                    productConsumer.increment();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"prod").start();

        new Thread(()->{
            try {
                System.out.println("消费线程启动");
                for (int i = 1; i <= 5 ; i++) {
                    productConsumer.decrement();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"consumer").start();

        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("boss叫停");
        productConsumer.stop();
    }
}
Bruin_W
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
阻塞队列及方法介绍
weixin_46120888的博客
03-13 2486
1.BlockingQueue简介 阻塞队列实际上就是个队列，只不过当队列里面东西是空的时候，当从队列中拿数据的时候会阻塞，当队列满了的时候，向队列中添加元素也会阻塞。当我不断取元素直到队列里的元素为空，会自动挂起线程，当我队列里面突然有元素了，会自动唤醒取元素的线程。这个阻塞队列的好处是我们不需要关心什么时候需要阻塞线程，什么时候需要唤醒线程，因为这一切BlockingQueue都一手给我包办了。 2.常见的BlockingQueue 2.1ArrayBlockingQueue 基于数组的阻塞队列实现，在
BlockingQueue（阻塞队列）详解
weixin_30478923的博客
04-24 2752
注意：该随笔内容完全引自http://wsmajunfeng.iteye.com/blog/1629354，写的很好，非常感谢，复制过来算是个积累，怕以后找不到。 一. 前言 　　在新增的Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了Blo...
一文掌握全部阻塞队列的使用
m0_71777195的博客
07-12 554
包括ArrayBlockingQueue、LinkedBlockingQueue、ConcurrentLinkedQueue 、PriorityBlockingQueue这些队列在用法上无本质区别，只是底层数据结构和加锁方式不一样。其中PriorityBlockingQueue逻辑有点不同，队列元素支持按优先级排序取出，其实就是阻塞队列里对于优先级队列的实现，支持排序。简单的生产者-消费者模型(1P-3C)使用java复制代码 @Test// 编写1个生产者-3个消费者的模型// 1个生产者。
阻塞队列详解
热门推荐
罗伯特是疯子丶
07-13 1万+
序言 由于最近项目上遇到了高并发问题，而自己对高并发，多线程这里的知识点相对薄弱，尤其是基础，所以想系统的学习一下，以后可能会出一系列的JUC文章及总结 ，同时也为企业级的高并发项目做好准备。 本文是JUC文章的第六篇，如想看以往关于JUC文章，请点击JUC系列总结 此系列文章的总结思路大致分为三部分： 理论（概念）； 实践（代码证明）； 总结（心得及适用场景）。 在这里提前说也是为了防止大家看着看着就迷路了。 备注：本文的知识深度相对较浅，可能仅局限于应用层面，如您需要相应足够的深度，请另行查阅。
阻塞队列的使用
qq_62949535的博客
12-19 6875
1.线程是安全的2.当进行入队操作的时候,队列为满,入队操作就阻塞,直到队列非满的时候入队操作才完成3.当进行出队操作的时候,队列为空,出队操作就阻塞,直到队列非空的时候出队操作才完成生产者消费者模型:例如:3个人包饺子,其中有一个人需要生产饺子皮,他就是生产者,另外的两个人就是消费者,而生产者生产的饺子皮放在桌子上,桌子就是"交易场所".如果生产者生产过快饺子皮已经放满了桌子,他就能进行阻塞等待,如果是饺子皮的生产速度慢于包饺子的速度,那消费者就能够进行阻塞等待。
14-阻塞队列BlockingQueue实战及其原理分析二.pdf
06-09
阻塞队列（BlockingQueue）是一种特殊的队列，它支持两个附加操作：阻塞的插入方法put和阻塞的移除方法take。BlockingQueue继承了Queue接口，是Java 5中加入的。 BlockingQueue常用方法示例： 1. add(E e)：添加一...
并发容器之ArrayBlockingQueue和LinkedBlockingQueue实现原理详解
06-20
ArrayBlockingQueue和LinkedBlockingQueue是Java并发容器中两个常用的阻塞队列实现，分别基于数组和链表存储元素。它们都继承自AbstractQueue类，并实现了BlockingQueue接口，提供了线程安全的队列操作。 ...
JAVA上百实例源码以及开源项目
01-03
　Java编写的HTML浏览器源代码，一个很简单甚至不算是浏览器的HTML浏览器，使用方法： 　可直接输入文件名或网络地址，但必需事先连入网络。 Java编写的山寨QQ，多人聊天+用户在线 21个目标文件 摘要:JAVA源码,...
JAVA上百实例源码以及开源项目源代码
12-11
显示出当前时间及年份，还可以选择年份及月份和日期 Java编写的HTML浏览器 一个目标文件 摘要:Java源码,网络相关,浏览器 Java编写的HTML浏览器源代码，一个很简单甚至不算是浏览器的HTML浏览器，使用方法： 可直接...
java阻塞队列的使用
xiao_yu_gan的博客
04-16 1543
1、介绍 阻塞队列，其实就是满足队列操作（先进先出）的一个数据集合，同时满足存取数据时的阻塞功能。 先进入阻塞队列的对象，会先被消费掉。 当阻塞队列已满时，生产者线程添加对象操作会被阻塞。 当阻塞队列已空时，消费者线程取出对象操作会被阻塞。 2、API分析 阻塞队列的直接接口为BlockingQueue，此接口内部定义了操作队列的各种方法。 BlockingQueue间接实现了Collection接口，所以阻塞队列其实就是一个集合，操作集合的各种方法，阻塞队列也满足。 核心方法 方法类型 抛
阻塞队列的操作方法
Leon_Jinhai_Sun的博客
01-03 1063
在阻塞队列中，提供了四种处理方式 1. 插入操作 add(e)：添加元素到队列中，如果队列满了，继续插入元素会报错，IllegalStateException。 offer(e) :添加元素到队列，同时会返回元素是否插入成功的状态，如果成功则返回true put(e)：当阻塞队列满了以后，生产者继续通过put添加元素，队列会一直阻塞生产者线程，知道队列可用 offer(e,time,unit)：当阻塞队列满了以后继续添加元素，生产者线程会被阻塞指定时间，如果超时，则线程直接退出 2. 移...
干货 | 45张图庖丁解牛18种Queue，你知道几种？
架构师小秘圈
09-09 456
来源 |悟空聊架构（ID：PassJava666）在讲《21张图讲解集合的线程不安全》那一篇，我留了一个彩蛋，就是Queue（队列）还没有讲，这次我们重点来看看Java中的Queue家...
阻塞队列（BlockingQueue）图解，以及实现类的简述
qq_40823802的博客
08-03 992
阻塞队列：顾名思义，首先他是一个队列，而一个阻塞队列在数据结构中所起的作用大致如图所示 相当于“生产者和消费者问题”。 当阻塞队列是空时：从队列中获取元素的操作将会被阻塞。 当阻塞队列是满时：往队列里添加元素的操作将会被阻塞。 试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他线程往空队列插入新的元素。同样， 试图往已满的阻塞队列添加新元素的线程同样也会被阻塞，直到其他的线程从列中移除一个或多...
【java并发】阻塞队列的使用——CSDN博客
武哥聊编程
06-07 349
博客地址：http://blog.csdn.net/eson_15/article/details/51586127
阻塞队列的简单使用
u013657993的专栏
07-29 197
概要分类 public interface BlockingQueue<E> extends Queue<E> { //这两个一对 不能立即被执行就会抛异常 boolean add(E var1); boolean remove(Object var1); //这个直接会返回一个结果 boolean offer(E var1); E poll(); 【这个是父类Queue里面的方法】 //这两个不能立即被执行...
阻塞队列BlockingQueue用法
weixin_33730836的博客
01-14 107
多线程环境中，通过队列可以很容易实现数据共享，比如经典的“生产者”和“消费者”模型中，通过队列可以很便利地实现两者之间的数据共享。 假设我们有若干生产者线程，另外又有若干个消费者线程。如果生产者线程需要把准备好的数据共享给消费者线程，利用队列的方式来传递数据，就可以很方便地解决他们之间的数据共享问题。但如果生产者和消费者在某个时间段内，万一发生数据处理速度不匹配的情况呢？理想情况下，如果生产者产...
ConcurrentLinkedQueue并发队列和LinkedBlockingQueue阻塞队列的详细用法和示例
纸上得来终觉浅，绝知此事要躬行
09-13 2396
参考文章：http://blog.csdn.net/ac903919/article/details/6967728，http://www.cnblogs.com/linjiqin/archive/2013/05/30/3108188.html 1.LinkedBlockingQueue：java.util.concurrent API中的解释： [java] view pl
java 阻塞队列 实现原理
最新发布
09-05
Java阻塞队列是一种线程安全的数据结构，它提供了同步的功能，用于在多线程环境中安全地进行数据交换和通信。其实现原理主要涉及以下几个方面。 首先，阻塞队列的实现会使用锁机制确保线程安全。Java中可以使用ReentrantLock或synchronized关键字来实现锁，在对队列进行操作时会对其进行加锁，保证同一时刻只有一个线程能够访问队列。 其次，阻塞队列内部会使用条件变量或信号量来实现线程间的协调与通信。当队列为空时，消费者线程需要等待直到队列有数据可取；当队列已满时，生产者线程需要等待直到队列有空位置可放入新数据。通过条件变量或信号量的等待和唤醒机制，实现了线程间的同步和互斥。 此外，阻塞队列通常还会使用一个循环数组来存储数据。循环数组在插入和删除元素时能够高效地利用已分配的内存空间，避免了频繁的扩容和内存拷贝。同时，循环数组的读写指针可以通过取模运算得到，实现环形循环。 最后，阻塞队列还会根据不同的需求提供不同的阻塞操作。例如，用于插入元素的put()方法在队列已满时会阻塞直到有空位置可用，用于获取元素的take()方法在队列为空时会阻塞直到有数据可取。这些阻塞操作的实现依赖于同步和协调机制，保证了线程安全和数据一致性。 总之，Java阻塞队列通过使用锁、条件变量或信号量、循环数组等机制，实现了线程安全和线程间的同步与通信。它是多线程编程中常用的工具，能够有效地管理数据的生产和消费，提高多线程程序的可靠性和性能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值