浅谈阻塞队列BlockingQueue

最新推荐文章于 2024-04-01 14:05:15 发布
最新推荐文章于 2024-04-01 14:05:15 发布
阅读量572 收藏
点赞数 1
分类专栏： 多线程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iwlnner/article/details/115526824
版权

一、什么是阻塞队列？

首先，队列我们应该都了解，是一种常见的数据结构，特点是先进先出（FIFO）

结合生活中的例子，当火锅店中人满为患座位占满时，通常的做法是安排后来的顾客在候客区等待正在就餐的顾客，而不是让顾客直接离开。此时的场景对于商家来说是希望存在阻塞（候客区）的。而在实际开发中，有时会遇到需要阻塞或者不得不阻塞的场景，为了对阻塞的线程进行管理，调度，就有了本节所讲的阻塞队列接口java.util.concurrent.BlockingQueue。这里对其下一个简单的定义：

阻塞：必须要阻塞/不得不阻塞

阻塞队列是一个队列，在数据结构中起到的作用如下图：

在这里插入图片描述
阻塞队列的特点：

  1. 当队列是空的，从队列中获取元素的操作将会被阻塞
  2. 当队列是满的，从队列中添加元素的操作将会被阻塞
  3. 试图从空的队列中获取元素的线程将会被阻塞，直到其他线程往空的队列插入新的元素
  4. 试图向已满的队列中添加新元素的线程将会被阻塞，直到其他线程从队列中移除一个或多个元素或者完全清空，使队列变的空闲起来并后续新增

二、为什么要用阻塞队列

JUC发布之前，在多线程环境下，我们不仅要控制线程的阻塞和唤醒，还要兼顾效率和线程安全，给我们的程序带来了更大的复杂度。

在多线程领域，在某些情况下会挂起（wait）线程（即阻塞），一旦条件满足，被挂起的线程又会自动被唤醒(notify)。在以往的多线程业务开发中，往往需要我们自己来编写代码来判断什么时候调用生产线程，什么时候调用消费线程。而BlockingQueue帮我们在“生产-消费”关系中充当了条件判断的角色，因此我们就不需要关心什么时候阻塞线程，什么时候唤醒线程，BlockingQueue帮我们一手包办啦。

三、如何使用阻塞队列

首先，让我们来看看BlockingQueue的体系架构：

在这里插入图片描述没错，你没看错，神秘的BlockingQueue原来是Queue的子接口！而Queue又是Collection接口的子接口，与我们常用的List和Set平级。BlockingQueue的实现类有很多，下面对这些类进行简单的介绍：

  • ArrayBlockingQueue：由数组结构组成的有界阻塞队列
  • LinkedBlockingQueue：由链表结构组成的有界（但大小默认值为Integer.MAX_VALUE）阻塞队列
  • PriorityBlockingQueue：支持优先级排序的无界阻塞队列
  • DelayQueue：使用优先级队列实现的延迟无界阻塞队列
  • SynchronousQueue：不存储元素的阻塞队列，也即单个元素的队列（队列中永远只有一个元素，生产一个就消费一个）
  • LinkedTransferQueue：由链表组成的无界阻塞队列
  • LinkedBlockingDeque：由链表组成的双向阻塞队列

以上常用的阻塞队列有两个，即ArrayBlockingQueue和LinkedBlockingQueue，本文针对ArrayBlockingQueue进行单独介绍。

了解了BlockingQueue的体系架构之后，让我们来看看BlockingQueue有哪些常用的方法。BlockingQueue的常用方法总结起来有四大类型：抛出异常、特殊值、阻塞和超时退出，这些方法的归类如下所示：

方法类型抛出异常特殊值阻塞超时
插入add(e)offer(e)put(e)offer(e,time,unit)
移除remove()poll()take()poll(time,unit)
检查element()peek()不可用不可用

下面通过代码演示更好的理解上面的归类

1.抛出异常类型

1）插入add(e)

package cn.edu.zknu.juc;

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

public class BlockingQueueDemo {

    public static void main(String[] args) {
        //测试第一组抛出异常类型的插入add(e)方法
        testAdd1();
    }

    private static void testAdd1() {
        //初始化容量为3的阻塞队列
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
        //add(e)返回boolean类型：BlockingQueue public abstract boolean add(String e)
        System.out.println(blockingQueue.add("A"));
        //由于ArrayBlockingQueue底层数据结构是数组，类似于ArrayList，所以允许该队列存放相同元素
        System.out.println(blockingQueue.add("A"));
        System.out.println(blockingQueue.add("B"));
        //此时放入元素的数量超出该队列的容量
        //System.out.println(blockingQueue.add("C"));
    }
}

运行结果：
在这里插入图片描述
结论：当使用add(e)插入队列的元素数量没有超过队列的容量时，程序正常执行

package cn.edu.zknu.juc;

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

public class BlockingQueueDemo {

    public static void main(String[] args) {
        //测试第一组抛出异常类型的插入add(e)方法
        testAdd1();
    }

    private static void testAdd1() {
        //初始化容量为3的阻塞队列
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
        blockingQueue.add("A");
        //由于ArrayBlockingQueue底层数据结构是数组，类似于ArrayList，所以允许该队列存放相同元素
        blockingQueue.add("A");
        blockingQueue.add("B");
        //此时放入元素的数量超出该队列的容量,报错
        blockingQueue.add("C");
    }
}

运行结果：
在这里插入图片描述
结论：当使用add()插入队列的元素数量超出该队列的容量时，报队列满的非法状态异常Queue full

2）移除remove()

package cn.edu.zknu.juc;

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

public class BlockingQueueDemo {

    public static void main(String[] args) {
        //测试第一组抛出异常类型的移除remove()方法
        testRemove1();
    }

    private static void testRemove1() {
        //初始化容量为3的阻塞队列
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
        blockingQueue.add("A");
        blockingQueue.add("B");
        blockingQueue.add("C");
        //根据队列的数据结构特点，移除顺序为A-B-C
        System.out.println(blockingQueue.remove());
        //Queue public abstract String remove()
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        //System.out.println(blockingQueue.remove());
    }
}

运行结果：
在这里插入图片描述
结论：当阻塞队列有元素时，使用remove()移除元素时，程序正常运行

package cn.edu.zknu.juc;

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

public class BlockingQueueDemo {

    public static void main(String[] args) {
        //测试第一组抛出异常类型的移除remove()方法
        testRemove1();
    }

    private static void testRemove1() {
        //初始化容量为3的阻塞队列
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
        blockingQueue.add("A");
        blockingQueue.add("B");
        blockingQueue.add("C");
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
    }
}

运行结果：
在这里插入图片描述
结论：当阻塞队列为空时，使用remove()移除元素时，程序报NoSuchElementException异常

3)检查element()

package cn.edu.zknu.juc;

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

public class BlockingQueueDemo {

    public static void main(String[] args) {
        //测试第一组抛出异常类型的检查元素element()方法
        testElement1();
    }

    private static void testElement1() {
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
        //blockingQueue.add("A");
        //blockingQueue.add("B");
        //检查阻塞队列的队首是哪个元素Queue public abstract String element()
        System.out.println(blockingQueue.element());
    }
}

运行结果：
在这里插入图片描述
结论：同remove()方法，当阻塞队列中没有元素时，调用element()方法会报NoSuchElementException异常

2.特殊值类型

1)插入offer(e)

package cn.edu.zknu.juc;

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

public class BlockingQueueDemo {

    public static void main(String[] args) {
    	//测试第二组特殊值类型的插入offer(e)方法
        testOffer2();
    }

    private static void testOffer2() {
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
        //BlockingQueue public abstract boolean offer(String e)
        System.out.println(blockingQueue.offer("A"));
        System.out.println(blockingQueue.offer("A"));
        System.out.println(blockingQueue.offer("B"));
        //此时放入元素的数量超出该队列的容量，返回false
        System.out.println(blockingQueue.offer("C"));
    }
}

运行结果：
在这里插入图片描述
结论：与抛出异常的add(e)方法不同，当向阻塞队列中新增元素的数量超过队列容量时，offer()方法返回false，不会报异常

2）移除poll()

package cn.edu.zknu.juc;

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

public class BlockingQueueDemo {

    public static void main(String[] args) {
    	//测试第二组特殊值类型的移除poll()方法
        testPoll2();
    }

    private static void testPoll2() {
        //初始化容量为3的阻塞队列
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
        blockingQueue.add("A");
        blockingQueue.add("B");
        //根据队列的数据结构特点，移除顺序为A-B-C
        //Queue public abstract String poll()
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
    }
}

运行结果：
在这里插入图片描述
结论：与抛出异常的remove()方法不同，当阻塞队列中不存在可移除的元素时，调用poll()方法返回null，不会报异常

3）检查peek()

package cn.edu.zknu.juc;

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

public class BlockingQueueDemo {

    public static void main(String[] args) {
        //测试第二组特殊值类型的检查元素peek()方法
        testPeek2();
    }

    private static void testPeek2() {
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
        /*blockingQueue.add("A");
        blockingQueue.add("B");*/
        //检查阻塞队列的队首是哪个元素Queue public abstract String peek()
        System.out.println(blockingQueue.peek());
    }

运行结果：
在这里插入图片描述
结论：与抛出异常的element()方法不同，当阻塞队列中不存在元素时，调用peek()方法返回null，不会报异常

3.阻塞类型

1）插入put(e)

package cn.edu.zknu.juc;

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

public class BlockingQueueDemo {

    public static void main(String[] args){
    	//测试第三组阻塞类型的插入元素方法put(e)
        testPut31();
        //模拟多线程环境下解除put(e)方法造成的线程阻塞
        //testPut32();
    }

    private static void testPut31() {
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(1);
        System.out.println(blockingQueue.add("A"));
        try{
        	//BlockingQueue public abstract void put(String e) throws InterruptedException
            //插入新的元素“C”,由于队列的容量为1，所以该队列陷入阻塞状态
            blockingQueue.put("C");
            System.out.println("程序已经被阻塞，随便敲点什么都不会被执行。。。");
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }

    private static void testPut32(){
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(1);
        System.out.println(Thread.currentThread().getName()+"-----"+blockingQueue.add("A"));
        System.out.println(Thread.currentThread().getName()+"-----初始队首元素："+blockingQueue.element());
        //新建一个子线程
        new Thread(()->{
            //睡眠3秒
            try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); }
            //移除队列中的“A”元素
            System.out.println(Thread.currentThread().getName()+"-----移除队列中的元素："+blockingQueue.remove());
        }).start();
        try{
            System.out.println(Thread.currentThread().getName()+"-----继续正常执行");
            //插入新的元素“C”,此时由于队列中的“A”还没有被移除，队列的容量为1，所以该队列陷入阻塞状态
            blockingQueue.put("C");
            System.out.println(Thread.currentThread().getName()+"-----插入新元素后队首元素："+blockingQueue.element());
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

testPut31运行结果：
在这里插入图片描述
testPut32运行结果：
在这里插入图片描述

结论：当要插入元素的阻塞队列已满时，使用put(e)方法会造成程序一直处于阻塞状态，直到从队列中移除元素才会将新元素插入该队列。

2）移除take()

package cn.edu.zknu.juc;

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

public class BlockingQueueDemo {

    public static void main(String[] args){
        //测试第三组阻塞类型的移除元素take()方法
        //testTake31();
        //模拟多线程环境下解除take()方法造成的线程阻塞
        //testTake32();
    }

    private static void testTake31() {
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(1);
        System.out.println(blockingQueue.add("A"));
        try{
            //BlockingQueue public abstract String take() throws InterruptedException
            //移除队首的元素,返回被移除的元素
            System.out.println(blockingQueue.take());
            //由于此时阻塞队列中已经没有元素，所以队列进入阻塞状态
            System.out.println(blockingQueue.take());
            System.out.println("程序已经被阻塞，随便敲点什么都不会被执行。。。");
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }

	private static void testTake32() {
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(1);
        System.out.println(Thread.currentThread().getName()+"-----初始化插入元素："+blockingQueue.add("A"));

        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"-----"+blockingQueue.remove());
            System.out.println(Thread.currentThread().getName()+"-----元素A已经被移除，队列中没有元素了。。。");
            //线程睡眠3秒
            try { TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) { e.printStackTrace();}
            System.out.println(Thread.currentThread().getName()+"-----新插入元素结果："+blockingQueue.add("D"));
        },"孙培阳").start();

        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"-----进入李扬扬线程。。。");
            try {
                System.out.println(Thread.currentThread().getName()+"-----"+blockingQueue.take());
                System.out.println(Thread.currentThread().getName()+"-----不等到队列中有元素，我就不执行。。。");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"李扬扬").start();
    }
}

testTake31运行结果：
在这里插入图片描述
testTake32运行结果：
在这里插入图片描述
结论：当要移除元素的阻塞队列为空时，使用take()方法会造成程序一直处于阻塞状态，直到向队列中插入新的元素才会将该新元素从队列中移除。

4.超时退出类型

1）插入方法offer(e,time,unit)

package cn.edu.zknu.juc;

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

public class BlockingQueueDemo {

    public static void main(String[] args){
        //测试第四组超时退出类型offer(e,time,unit)方法
        testOffer41();
        //模拟多线程环境下使用offer(e,time,unit)插入新元素
        //testOffer42();
    }

    private static void testOffer41() {
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(1);
        System.out.println(Thread.currentThread().getName()+"-----初始化插入元素："+blockingQueue.add("A"));
        try {
            //BlockingQueue public abstract boolean offer(String e, long timeout, TimeUnit unit) throws InterruptedException
            System.out.println("超时退出插入方法结果："+blockingQueue.offer("B", 3, TimeUnit.SECONDS));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static void testOffer42() {
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(1);
        System.out.println(Thread.currentThread().getName()+"-----初始化插入元素："+blockingQueue.add("A"));
        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+"-----超时退出插入方法结果："+blockingQueue.offer("B", 3, TimeUnit.SECONDS));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"孙培阳").start();

        new Thread(()->{
            try { TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) { e.printStackTrace();}
            System.out.println(Thread.currentThread().getName()+"-----移除元素结果："+blockingQueue.remove());
            System.out.println(Thread.currentThread().getName()+"-----获取队列中最新元素："+blockingQueue.element());
        },"李扬扬").start();
    }
}

testOffer41运行结果：
在这里插入图片描述

testOffer42运行结果：
在这里插入图片描述

结论：当要插入元素的阻塞队列已满时，使用offer(e,time,unit)方法会造成程序在指定时间内处于阻塞状态，如果在指定时间内该队列一直是满的，则结束程序。

2）移除元素poll(time,unit)

package cn.edu.zknu.juc;

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

public class BlockingQueueDemo {

    public static void main(String[] args){
        //testPoll41();
        testPoll42();
    }

    private static void testPoll41() {
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(1);
        System.out.println("插入新元素："+blockingQueue.add("A"));
        System.out.println("移除元素："+blockingQueue.remove());
        try {
            //BlockingQueue public abstract String poll(long timeout, TimeUnit unit) throws InterruptedException
            System.out.println("超时退出移除的元素："+blockingQueue.poll(3, TimeUnit.SECONDS));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static void testPoll42() {
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(1);
        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+"-----开始移除元素");
                System.out.println(Thread.currentThread().getName()+"-----超时退出移除方法结果："+blockingQueue.poll(3, TimeUnit.SECONDS));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"孙培阳").start();

        new Thread(()->{
            try { TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) { e.printStackTrace();}
            System.out.println(Thread.currentThread().getName()+"-----插入元素结果："+blockingQueue.add("P"));
        },"李扬扬").start();
    }

testPoll41运行结果：
在这里插入图片描述
testPoll42运行结果：
在这里插入图片描述
结论：当使用poll(time,unit)方法对阻塞队列进行移除元素时，如果该队列的状态为空队列时，程序会在指定时间内等到队列中有元素时再进行移除，如果超过指定时间队列中仍没有元素可以移除，则结束程序。

通过以上对ArrayBlockingQueue不同方法的探究，我们不难总结出以下结论：
在这里插入图片描述

到这里，我们对ArrayBlockingQueue有了基本的认识和了解，如果感兴趣，可以看看这些方法底层的源码，了解其通过ReentrantLock对各个方法进行线程安全以及线程通信的工作原理，对于以后的工作和学习都是有帮助的，暂时先到这里。

iwlnner
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
java 中 阻塞队列BlockingQueue详解及实例
08-30
主要介绍了java 中 阻塞队列BlockingQueue详解及实例的相关资料,需要的朋友可以参考下
linkedblockingqueue 后 take 不消化_阻塞队列（3）LinkedBlockingQueue源码详解
weixin_31459571的博客
12-08 1798
问题输入图片说明LinkedBlockingQueue是什么？优缺点？应用场景？源码实现？个人启发？LinkedBlockingQueue双向并发阻塞队列。所谓双向是指可以从队列的头和尾同时操作，并发只是线程安全的实现，阻塞允许在入队出队不满足条件时挂起线程，这里说的队列是指支持FIFO/FILO实现的链表。要想支持阻塞功能，队列的容量一定是固定的，否则无法在入队的时候挂起线程。也就是capaci...
java队列正常关闭_Java中消息队列任务的平滑关闭详解
weixin_32101285的博客
02-27 238
前言消息队列中间件是分布式系统中重要的组件，主要解决应用解耦，异步消息，流量削锋等问题，实现高性能，高可用，可伸缩和最终一致性架构。目前使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ消息队列应用场景消息队列在实际应用中常用的使用场景：异步处理，应用解耦，流量削锋和消息通讯四个场景。本文主要给大家介绍的是关于Java中消息队列任务平滑...
JAVA 中 queue.add()和queue.offer()的区别
最新发布
m0_52320920的博客
04-01 423
此外,在Java的Queue接口中,add()方法是从Collection接口继承而来的,而offer()方法是Queue接口自身定义的。所以,从语义上讲,offer()方法更加符合队列的插入操作。如果使用add()方法,当队列已满时抛出异常,可能会导致程序崩溃或者其他不可预知的后果。相比之下,offer()方法返回一个布尔值,允许我们根据插入操作的成功或失败来采取相应的措施。queue.add()和queue.offer()都是向队列中插入元素的方法,但它们在队列已满时的行为有所不同。
BlockingQueue（阻塞队列）详解
kaven
02-19 1776
BlockingQueue（阻塞队列）详解 原文地址 BlockingQueue 一. 前言 在新增的Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了BlockingQueue家庭中的所有成员，包括他们各自的功能以及常见使用场景。 二. 认识Bl...
聊聊并发-Java中的阻塞队列
weixin_33895695的博客
12-23 540
转自：http://www.infoq.com/cn/articles/java-blocking-queue1. 什么是阻塞队列？阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作是：在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的线程会等待队列可用。阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，...
多线程之间交互线程之BlockingQueue
Bleach_kids的专栏
11-22 624
线程阀是一种线程与线程之间相互制约和交互的机制。 1、阻塞队列BlockingQueue是一个支持两个附加操作的队列，这两个附加操作是：队列为空时，获取元素的线程会等待队列变为非空；当队列满时，存储元素的线程会等待队列可用。阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿取元素的线程。阻塞队列作为生产者存放元素的容器，而消费者也只能从容器里拿取元素。（想要了
K8s源码分析(26)-Queue组件和DeltaFIFO组件
weixin_46073333的博客
09-25 355
上一篇文章里，我们主要介绍了和对象存储相关的组件 Store 接口以及它的实现结构体 cache，本质上说该接口和它的实现是对以前文章中介绍的 ThreadSafeStore 接口和它具体实现的更高级抽象，即 ThreadSafeStore 接口的操作需要针对资源对象以及对象的 key， 而 Store 接口有能力获取资源对象的 key， 所以该接口只针对资源对象操作。当然，两种组件针对资源对象的...
阻塞队列BlockingQueue的使用
01-07
在新增的Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。本文简要介绍下BlockingQueue...
10、阻塞队列BlockingQueue实战及其原理分析
03-07
10、阻塞队列BlockingQueue实战及其原理分析_
14-阻塞队列BlockingQueue实战及其原理分析二.pdf
06-09
14-阻塞队列BlockingQueue实战及其原理分析二.pdf
10、阻塞队列BlockingQueue实战及其原理分析.pdf
02-28
6.JUC并发工具类在大厂的应用场景详解 (1).pdf 7、深入理解 AQS 独占锁之 Reentrantlock 源码分析 (1).pdf 8、读写锁ReentrantReadWriteLock&StampLock详解.pdf ...10、阻塞队列BlockingQueue 实战及其原理分析.pdf
Java 如何中断在 take() 上阻塞的 BlockingQueue？
dodod2012的专栏
11-24 365
线程的代码，很常见，当服务停止时，如何停止被BlockingQueue阻塞的线程？，这将允许处理线程在等待一段时间而没有新输入时超时并终止。方案二：判断BlockingQueue是否未空，中断处理。优化方案：解决两个问题。
深入理解C#消息阻塞队列：实现线程间通信和数据传递 （BlockingCollection）以及使用BlockingCollection类、自定义消息阻塞队列 代码示例
weixin_48588665的博客
08-05 1306
探索C#消息阻塞队列：线程间通信、阻塞操作和应用实践，优化并发程序，避免竞争与死锁，自定义队列及性能对比。
ArrayBlockingQueue原理分析-take方法
Leon_Jinhai_Sun的博客
01-04 1086
take方法是一种阻塞获取队列中元素的方法 它的实现原理很简单，有就删除没有就阻塞，注意这个阻塞是可以中断的，如果队列没有数据那么就加入notEmpty条件队列等待(有数据就直接取走，方法结束)，如果有新的put线程添加了数据，那么put操作将会唤醒take线程，执行take操作。 public E take() throws InterruptedException { final ReentrantLock lock = this.lock; lock.lockInterruptibly(
ArrayBlockingQueue 取出null值问题
PeterOK的博客
10-20 1088
记录工作中遇到的问题，同时也希望可以帮助到有需要的朋友 ArrayBlockingQueue 相关知识网上很多帖子写的很好，还有丰富的demo，就不在此一一赘述了 这周在使用 ArrayBlockingQueue 时遇到一个问题，明明往队列中放（ 用的offer(String e, long timeout, TimeUnit unit) ）入了数据，但是取（ 用的poll(long ti...
sheng的学习笔记-BlockingQueue（阻塞队列）
coldstarry的专栏
12-06 961
BlockingQueue，ArrayBlockingQueue，LinkedBlockingQueue，SynchronousQueue， PriorityBlockingQueue，DelayQueue分析
Java并发编程之LinkedBlockingQueue阻塞队列详解
Stay Hungry, Stay Foolish
06-05 2947
简介LinkedBlockingQueue是一个用链表实现的有界阻塞队列，此队列按照先进先出（FIFO）的原则对元素进行排序。此队列的默认和最大长度是Integer.MAX_VALUE，LinkedBlockingQueue类有三个构造方法：// 默认构造方法，该方法会调用this(Integer.MAX_VALUE)，即默认最大长度是Integer.MAX_VALUE public Linked...
java blockingqueue_java – 如何中断blockingQueue阻塞在take()？
weixin_33930436的博客
02-20 1188
我有一个类，从一个BlockingQueue对象，并通过在连续循环中调用take()处理它们。在某些时候，我知道没有更多的对象将被添加到队列。如何中断take()方法，以便它停止阻塞？这里是处理对象的类：public class MyObjHandler implements Runnable {private final BlockingQueue queue;public class MyOb...
BlockingQueue是什么队列中的
07-22
`BlockingQueue` 是 Java 并发编程中的一个接口，它是一个支持阻塞操作的队列。 具体来说，`BlockingQueue` 继承自 `Queue` 接口，提供了一套阻塞的插入和获取元素的方法。当队列为空时，获取元素的操作会被阻塞，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值