[java并发] java高并发系列 - 第25天：掌握JUC中的阻塞队列

最新推荐文章于 2021-03-21 16:38:24 发布
最新推荐文章于 2021-03-21 16:38:24 发布
阅读量288 收藏
点赞数
分类专栏： Java # Java并发 文章标签： 队列 java 多线程 queue 分布式
原文链接：https://mp.weixin.qq.com/s/bsbgTAUkJBQeby1se0mltg
版权

原文链接：查看原文

感谢公众号“ 路人甲Java”的分享，如有冒犯，请联系删除，快去关注他吧
在这里插入图片描述

本文主要内容：

  1. 掌握Queue、BlockingQueue接口中常用的方法
  2. 介绍6种阻塞队列，及相关场景示例
  3. 重点掌握4种常用的阻塞队列

Queue接口

队列是一种先进先出（FIFO）的数据结构，java中用 Queue 接口来表示队列。

Queue 接口定义了6个方法：

public interface Queue<E> extends Collection<E>{
	boolean add(e);
	boolean offer(E e);
	E remove();
	E poll();
	E element();
	E peek();
}

每个Queue 方法都有两种形式：

  • 如果操作失败则抛出异常
  • 如果操作失败，则返回特殊值（null 或false，具体取决于操作），接口的常规结构如下表所示：
操作类型抛出异常返回特殊值
插入add(e)offer(e)
移除remove(e)poll()
检查element()peek()

Queue 从 Collection 继承的 add 方法插入一个元素，除非它违反了队列的容量限制，在这种情况下它会抛出 IllegalStateException; offer 方法与add不同之处仅在于它通过返回false来表示插入元素失败。

remove 方法和 poll 方法都移除并返回队列的头部，确切地移除哪个元素是由具体的实现来决定的，仅当队列为空时，remove 和 poll 方法的行为才有所不同，在这些情况下，remove 抛出 NoSuchElementException，而 poll 返回null。

element 和peak方法返回队列头部的元素，但不移除，它们之间的差异与 remove 和 poll 的方式完全不同，如果队列为空，则 element 抛出 NoSuchElementException，而peek 返回null。

队列一般不要插入空元素。

BlockingQueue 接口

BlockingQueue 位于juc中，俗称阻塞队列，阻塞队列首先它是一个队列，继承 Queue 接口，是队列就会遵循先进先出（FIFO） 的原则，又因为它是阻塞的，故与普通的队列有两点区别：

  1. 当一个线程向队列里面添加数据时，如果队列是满的，那么将阻塞该线程，暂停添加数据
  2. 当一个线程从队列里面取出数据时，如果队列是空的，那么将阻塞该线程，暂停取出数据

BlockingQueue 相关方法

操作类型抛出异常返回特殊值一直阻塞超时退出
插入add(e)offer(e)put(e)offer(e,timeout,unit)
移除remove()poll()take()poll(timeoout,unit)
检查element()peek()不支持不支持

重点来了，再来解释一下，加深印象：

  1. 3个可能会有异常的方法：add、remove、element；3个方法不会阻塞（是说队列满或空的情况下是否会阻塞）；队列满的情况下，add抛出异常；队列为空的情况，remove、element抛出异常
  2. offer、poll、peek也不会阻塞（是说队列满或队列为空的情况下是否会阻塞）；队列满的情况下，offser会返回false；队列为空的情况下，pool、peek返回null
  3. 队列满的情况下，调用put方法会导致当前线程阻塞
  4. 队列为空的情况下，调用take方法会导致当前编程阻塞
  5. offer(e,timeout,unit)，超时之前，插入成功返回true，否则返回false
  6. poll(timeout,unit) , 超时之前，获取到头部元素并将其移除，返回true，否则返回false

以上方法要记住，方便使用

BlockingQueue常见的实现类

看一下相关类图：

ArrayBlockingQueue

基于数组的阻塞队列实现，其内部维护一个定长的数组，用于存储队列元素。线程阻塞的实现是通过ReentrantLock来完成的，数据的插入与取出共用同一个锁，因此，ArrayBlockingQueue并不能实现生产、消费同时进行。而且在创建ArrayBlockingQueue时，我们还可以控制对象的内部锁是否采用公平锁，默认采用非公平锁。

LinkedBlockingQueue

基于单向链表的阻塞队列实现，在初始化 LinkedBlockingQueue的时候可以指定大小，也可以不指定，默认类似一个无限大小的容量（Integer.MAX_VALUE），不指定容量大小也是会有风险的，，一旦数据生产速度大于消费速度，系统内存将有可能耗尽，因此要谨慎操作。另外LinkedBlockingQueue中用于阻塞生产者、消费者的锁是两个（锁分离），因此生产与消费是可以同时进行的

PriorityBlockingQueue

一个支持优先级排序的无界阻塞队列，进入队列的元素会按照优先级进行排序

SychronousQueue

同步阻塞队列，SychronousQueue没有容量，与其他BlockingQueue不同，SynchronousQueue是一个不存储元素的BlockingQueue，每一个put操作必须要等待一个take操作，否则不能继续添加元素，反之亦然。

LinkedTransferQueue

LinkedTransferQueue是基于链表的FIFO无界阻塞队列，它出现在JDK7中，Doug Lea 大神说 LinkedTtransferQueue是一个聪明的队列，它是ConcurrentLinkedQueue、SychronousQueue(公平模式下) 、无界的LinkedBlockingQueue等的超集，LinkedTransferQueue 包含了 ConcurrentLinkedQueue 、 SychronousQueue 、LinkedBlockingQueue 三种队列的功能

下面我们来介绍每种阻塞队列的使用

ArrayBlockingQueue

有界阻塞队列，内部使用数组存储元素，有2个常用的改造方法

//capacity表示容量大小，默认内部采用非公平锁
public ArrayBlockingQueue(int capacity)
//capacity:容量大小，fair，内部是否是会使用公平锁
public ArrayBlockingQueue(int capacity,boolean fair)

需求： 业务系统中有很多地方需要推送通知，由于需要推送的数据太多，我们将需要推送的信息先丢到阻塞队列中，然后开一个线程进行处理真实发送，

代码如下：

package aboutThread.Concurrent.Day25;

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

public class Demo1 {
    //推送队列
    static ArrayBlockingQueue<String> pushQueue = new ArrayBlockingQueue<String>(10000);

    static{
        //启动一个线程做真实推送
        new Thread(() ->{
            while(true){
                String msg;
                try {
                    long startTime = System.currentTimeMillis();
                    //获取一条推送消息
                    msg =  pushQueue.take();
                    long endTime = System.currentTimeMillis();
                    //模拟推送耗时
                    TimeUnit.MILLISECONDS.sleep(500);
                    System.out.println(String.format("[%s,%s,take耗时:%s],%s,发送消息:%s", startTime, endTime, (endTime - startTime), Thread.currentThread().getName(), msg));           
                     }catch(InterruptedException e)
                     {
                        e.printStackTrace();
                     }
                     
                
            }
        }).start();
    }

    /**
     * 推送消息，需要发送推送消息的调用该方法，会将推送消息优先加入推送队列
     * @param msg
     * @throws InterruptedException
     */
    public static void pushMsg(String msg) throws InterruptedException{
        pushQueue.put(msg);
    }   

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i <= 5; i++) {
            String msg = "一起来学java并发，第" + i + "天";
            // 模拟耗时
            TimeUnit.SECONDS.sleep(i);
            Demo1.pushMsg(msg);
        }
    }

    
}

输出：

[1592218335056,1592218335057,take耗时:1],Thread-0,发送消息:一起来学java并发，第0天
[1592218335587,1592218336057,take耗时:470],Thread-0,发送消息:一起来学java并发，第1天
[1592218336562,1592218338059,take耗时:1497],Thread-0,发送消息:一起来学java并发，第2天
[1592218338563,1592218341064,take耗时:2501],Thread-0,发送消息:一起来学java并发，第3天
[1592218341567,1592218345066,take耗时:3499],Thread-0,发送消息:一起来学java并发，第4天
[1592218345571,1592218350070,take耗时:4499],Thread-0,发送消息:一起来学java并发，第5天

代码中我们使用了有界队列 ArrayBlockingQueue，创建ArrayBlockingQueue 时候需要指定容量大小，调用 pushQueue.put() 将推送信息放入队列中，如果队列已满，此方法会阻塞。代码中在静态块中启动了一个线程，调用 pushQueue.take(); 从队列中获取待推送的信息进行推送处理。

注意： ArrayBlockingQueue 如果队列容量设置的太小，消费者发送的太快，消费者消费的太慢的情况下，会导致队列空间满，调用put方法会导致发送者线程阻塞，所以注意设置合理的大小，协调好消费者的速度。

LinkedBlockingQueue

内部使用单项链表实现的阻塞队列，3个构造方法：

//默认构造方法，容量大小为Integer.MAX_VALUE
public LinkedBlockingQueue();
//创建指定容量大小的LinkedBlockingQueue
public LinkedBlockingQueue(int capacity);
//容量为Integer.MAX_VALUE,并将传入的集合丢入队列中
public LinkedBlockingQueue(Collection<? extends E> c);

LinkedBlockingQueue 的用法和 ArrayBlockingQueue 类似，建议使用的时候指定容量，如果不指定容量，插入的太快，移除的太慢，可能会产生OOM。

PriorityBlockingQueue

无界的优先级 阻塞队列，内部使用数组存储数据，达到容量时，会自动扩容，放入的元素会按照优先级进行排序，4个构造方法：

//默认的构造方法，默认初始化容量是11
public PriorityBlockingQueue();
//指定队列的初始化容量
public PriorityBlockingQueue(int initialCapacity);
//指定队列的初始化容量和放入元素的比较器
public PriorityBlockingQueue(int initialCapacity,Comparator<? super E> comparator);
//传入集合放入来初始化队列，传入的集合可以实现SortedSet 接口或者 PrioirtyQueue 接口进行排序，如果没有实现第二个接口，按正常顺序放入队列
public PriorityBlockingQueue(Colleciton<? extends E> c);

优先级队列放入元素的时候，会进行排序，所以我们需要指定排序规则，有2种方式：

  1. 创建 PriorityBlockingQueue 指定比较器 Comparator
  2. 放入的元素需要实现Comparable接口

上面两种方式必须选一个，如果2个都有，则走第一个规则排序！

需求： 还是上面的推送业务，目前推送是按照放入的先后顺序进行发送的，比如有些公告比较紧急，优先级比较高，需要快点发送，怎么搞？此时 PriorityBlockingQueue 就派上用场了，代码如下：

package aboutThread.Concurrent.Day25;

import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.TimeUnit;

public class Demo2 {
    /**
     * 推送消息封装
     */
    static class Msg implements Comparable<Msg> {
        // 优先级，越小优先级越高
        private int priority;
        // 推送的信息
        private String msg;

        public Msg(int priority, String msg) {
            this.priority = priority;
            this.msg = msg;
        }

        @Override
        public String toString() {
            return  "Msg{ " + "priority=" + priority + ",msg = '" + msg + "'}";
        }

        @Override
        public int compareTo(Msg o) {
            return Integer.compare(this.priority, o.priority);
        }

    }

    // 推送队列
    static PriorityBlockingQueue<Msg> pushQueue = new PriorityBlockingQueue<Msg>();

    static {
        // 启动一个线程做真实推送
        new Thread(() -> {
            while(true){
            Msg msg;
            try {
                long startTime = System.currentTimeMillis();
                // 获取一条推送信息，此方法会进行阻塞，直到返回结果
                msg = pushQueue.take();
                // 模拟推送耗时
                TimeUnit.MILLISECONDS.sleep(100);
                long endTime = System.currentTimeMillis();
                System.out.println(String.format("[%s,%s,take耗时：%s],%s,发送消息：%s", startTime, endTime,
                        (endTime - startTime), Thread.currentThread().getName(), msg));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        }).start();
    }

    public static void pushMsg(int priority,String msg) throws InterruptedException{
        pushQueue.put(new Msg(priority,msg));
    }

    public static void main(String[] args) throws InterruptedException{
        for (int i = 5; i >= 1; i--) {
            String msg = "一起学习java高并发，第" + i + "天";
            Demo2.pushMsg(i, msg);    
        }

    }
}

输出:

[1592222896712,1592222896814,take耗时：102],Thread-0,发送消息：Msg{ priority=2,msg = '一起学习java高并发，第2天'}
[1592222896837,1592222896940,take耗时：103],Thread-0,发送消息：Msg{ priority=1,msg = '一起学习java高并发，第1天'}
[1592222896941,1592222897045,take耗时：104],Thread-0,发送消息：Msg{ priority=3,msg = '一起学习java高并发，第3天'}
[1592222897046,1592222897150,take耗时：104],Thread-0,发送消息：Msg{ priority=4,msg = '一起学习java高并发，第4天'}
[1592222897150,1592222897254,take耗时：104],Thread-0,发送消息：Msg{ priority=5,msg = '一起学习java高并发，第5天'}

main中放入了5条推送消息，i作为消息的优先级按倒序放入的，最终输出结果中按照优先级由小到大输出。注意Msg实现了 Comparable 接口，具有了比较功能。

SynchronousQueue

同步阻塞队列，SynchronousQueue 没有容量，与其他BlockingQueue 不同，SynchornousQueue是一个不存储元素的BlockingQueue，每一个put操作必须要等待一个take操作，否则不能继续添加元素，反之亦然。SynchronousQueue在现实中使用的不多，线程池中有用到过，Executors.newCachedThreadPool()实现中用到了这个队列，当有任务丢入线程池的时候，如果已创建的工作线程都在忙于处理任务，则会新建一个线程来处理丢入队列的任务。

示例代码：

package aboutThread.Concurrent.Day25;

import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

public class Demo3 {
    static SynchronousQueue<String> queue = new SynchronousQueue<>();

    public static void main(String[] args) throws InterruptedException{ 
        new Thread(() ->{
            try {
                long startTime = System.currentTimeMillis();
                queue.put("java高并发系列，Aran");
                long endTime = System.currentTimeMillis();
                System.out.println(String.format("[%s,%s,take耗时：%s],%s", startTime,endTime,(endTime - startTime),Thread.currentThread().getName()));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        //休眠5秒之后，从队列中take一个元素
        TimeUnit.SECONDS.sleep(5);
        System.out.println(System.currentTimeMillis() + "调用take获取并移除元素，" + queue.take());
    }
}

1592296895479调用take获取并移除元素，java高并发系列，Aran
[1592296890474,1592296895480,take耗时：5006],Thread-0

main方法中启动了一个线程，调用 queue.put 方法向队列中丢入一条数据，调用的时候产生了阻塞，从输出结果中可以看出，直到take方法被调用时，put方法才从阻塞状态恢复正常。

DelayQueue

DelayQueue是一个支持延时获取元素的无界阻塞队列，里面的元素全部都是“可延期”的元素，列头的元素是最先“到期” 的元素，如果队列里面没有元素到期，是不能从列头获取元素的，哪怕有元素也不行，也就是说只有在延迟期到时才能够从队列中取元素。

需求： 还是推送业务，有时候我们希望早上9点或者其他指定的时间进行推送，如何实现呢？此时 DelayQueue 就派上用场了。

DelayQueue类的声明：

public class DelayQueue<E extends Delayed> extends AbstractQueue<E> implements BlockingQueue<E>

元素E需要实现接口 Delayed 我们看下这个接口的代码：

public interface Delayed extends Comparable<Delayed>{
	long getDelay(TimeUnit unit); 
}

Delayed 继承了Comparable 接口，这个接口是用来做比较的， DelayQueue 内部使用 PriorityQueue 来存储数据的，PriorityQueue 是一个优先级队列，丢入的数据会进行排序，排序方法调用的是 Comparable 接口中的方法。下面主要说一下 Delayed 接口中的getDelay方法：此方法在给定的时间单位内返回与此对象关联的剩余延迟时间。

对推送我们再做一下处理，让其支持定时发送（定时在将来某个时间也可以说是延迟发送），代码如下：

package aboutThread.Concurrent.Day25;

import java.util.Calendar;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

public class Demo4 {
    // 推送信息封装
    static class Msg implements Delayed {
        // 优先级，越小优先级越高
        private int priority;
        // 推送的信息
        private String msg;
        // 定时发送时间，毫秒格式
        private long sendTimeMs;

        public Msg(int priority, String msg, long sendTimeMs) {
            this.priority = priority;
            this.msg = msg;
            this.sendTimeMs = sendTimeMs;
        }

        @Override
        public String toString() {
            // TODO Auto-generated method stub
            return "Msg{" + 
                    "priority=" + priority + 
                    ",msg = '"+msg+"'"+
                    ",sendTimeMs = " + sendTimeMs + 
                    "}";
        }

        @Override
        public long getDelay(TimeUnit unit) {
             return unit.convert(this.sendTimeMs - Calendar.getInstance().getTimeInMillis(), TimeUnit.MILLISECONDS);
        }

        @Override
        public int compareTo(Delayed o) {
            if(o instanceof Msg){
                Msg c2 = (Msg) o;
                return Integer.compare(this.priority, c2.priority);
            }
            return 0;
        }
        
        
    }

    //推送队列
    static DelayQueue<Msg> pushQueue = new DelayQueue<Msg>();

    static{
        //启动一个线程做真实推送
        new Thread(() ->{
            while(true){
                Msg msg;
                try {
                    //获取一条推送信息，此方法会进行阻塞，直到返回结果
                    msg = pushQueue.take();
                    //此处可做真实推送
                    long endTime = System.currentTimeMillis();
                    System.out.println(String.format("定时发送时间：%s,实际发送时间：%s,发送消息：%s",msg.sendTimeMs,endTime,msg));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

    //推送消息，需要发送推送消息的调用该方法，会将推送信息先加入推送对垒
    public static void pushMsg(int priority,String msg,long sendTimeMs) throws InterruptedException{
        pushQueue.put(new Msg(priority,msg,sendTimeMs));
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 5; i >= 1; i--) {
            String msg = "一起来学java并发，第"+ i +" 天";
            Demo4.pushMsg(i, msg, Calendar.getInstance().getTimeInMillis() + i * 2000);
        }
    }
}

输出：

定时发送时间：1592298651432,实际发送时间：1592298651435,发送消息：Msg{priority=1,msg = '一起来学java并发，第1 天',sendTimeMs = 1592298651432}
定时发送时间：1592298653432,实际发送时间：1592298653434,发送消息：Msg{priority=2,msg = '一起来学java并发，第2 天',sendTimeMs = 1592298653432}
定时发送时间：1592298655432,实际发送时间：1592298655437,发送消息：Msg{priority=3,msg = '一起来学java并发，第3 天',sendTimeMs = 1592298655432}
定时发送时间：1592298657431,实际发送时间：1592298657437,发送消息：Msg{priority=4,msg = '一起来学java并发，第4 天',sendTimeMs = 1592298657431}
定时发送时间：1592298659410,实际发送时间：1592298659415,发送消息：Msg{priority=5,msg = '一起来学java并发，第5 天',sendTimeMs = 1592298659410}

可以看出实际发送时间，和定时发送时间基本一致，代码中 Msg 需要实现 Delay 接口，重点在于 getDelay 方法，这个方法返回剩余的延迟时间，代码中使用 this.sendTimeMs 减去当前时间的毫秒格式时间，得到剩余延迟时间。

LinkedTransferQueue

LinkedTransferQueue 是一个由链表结构组成的无界阻塞TransferQueue队列。相对于其他阻塞队列，LinkedTransferQueue 多了 tryTransfer和transfer方法。

LinkedTransferQueue类继承自AbstractQueue抽象类，并且实现了 TransferQueue接口：

public interface TransferQueue<E> extends BlockingQueue<E>{
	//如果存在一个消费者已经等待接受它，则立即传送指定的元素，否则返回false，并且不进入队列
	boolean tryTransfer(E e);
	//如果存在一个消费者已经等待接收它，则立即传送指定的元素，否则等待直到元素被消费者接收。
	void transfer(E e) throws InterruptedException;
	//在上述方法的基础上设置超时时间
	boolean tryTransfer(E e,long timeout,TimeUnit unit) throws InterruptedException
	//如果至少有一位消费者在等待，则返回true
	boolean hasWaitingConsumer();
	//获取所有等待获取元素的小费线程数量
	int getWaitingConsumerCount();
}

再看一下上面的这些方法，transfer(E e) 方法和SynchronousQueue的 put方法类似，都需要等待消费者获取元素，否则一直等待。其他方法 ArrayBlockingQueue 、LinkedBlockingQueue 中的方法类似。

总结

  1. 重点需要了解 BlockingQueue 中的所有方法，以及他们的区别
  2. 重点掌握 ArrayBlockingQueue 、 LinkedBlockingQueue 、PriorityBlockingQueue 、DelayQueue的使用场景
  3. 需要处理的任务有优先级的，使用 PriorityBlockingQueue
  4. 处理的任务需要延时处理的，使用 DelayQueue
Aran_
关注
专栏目录
Java系列技术之多线程与JUC
10-21
系统地讲多线程的基础应用知识和JUC工具包里对线程的核心工具类的具体使用方法，为高并发编程打下基础。
java--JUC快速入门（彻底搞懂JUC）
qq_53808097的博客
08-08 2854
线程池：一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。
Java源码解读系列6—LinkedBlockingQueue（JDK1.8 ）
JayLaiSCUT的博客
03-21 4627
1 概述 LinkedBlockingqueue（简称LBQ）是BlockingQueue接口的实现类，是一种无界、阻塞、线程安全的FIFO队列。LBQ底层存储基于链表，头节点为哨兵节点，里面的数据域（item）为空。插数据时从尾节点插入，取数据时从头节点（若队列非空，则找第一个item不为空的节点）获取。相对于非阻塞的ConcurrentLinkedQueue（简称CLQ队列），LBQ的实现比较简单，就是采用添加和取出两把锁来保证线程安全。 2 链表节点的数据结构 static class Node
LinkedBlockingQueue的poll、remove、take区别
qq_30908729的博客
07-26 2万+
LinkedBlockingQueue的poll、remove、take比较 解决方法：http://yayihouse.com/yayishuwu/chapter/1357
java高并发系列 - 第13天：JUC中的Condition对象
路人甲Java
07-19 704
java高并发系列第13篇文章本文内容synchronized中实现线程等待和唤醒Condition简介及常用方法介绍及相关示例使用Condition实现生产者消费者使用...
java并发编程：juc线程池
08-09
Java并发编程中的JUC线程池是Java程序员必须掌握的关键技术之一，它允许开发者高效地管理并发执行的任务，充分利用多核处理器的性能。线程池的出现解决了在并发环境中线程创建、销毁带来的开销，提高了系统资源的...
java并发编程：juc、aqs
最新发布
08-09
Java并发编程中的`JUC`(Java Util Concurrency)库是Java平台中用于处理多线程问题的核心工具包，它提供了一系列高效、线程安全的工具类，帮助开发者编写并发应用程序。`AQS`(AbstractQueuedSynchronizer)是JUC库中的...
Java 多线程与并发(15-26)-JUC集合- ConcurrentLinkedQueue详解.pdf
07-27
`ConcurrentLinkedQueue`是Java实用工具包（J.U.C）中的一个高性能线程安全队列，主要用于解决多线程环境下并发访问集合的问题。它基于链表实现，具有非阻塞特性和无界队列的特点。`ConcurrentLinkedQueue`遵循FIFO...
Java-并发（Concurrent）编程
07-15
5. **Java并发工具包(JUC)**：包括原子类、并发容器（如`ConcurrentHashMap`）、阻塞队列（如`ArrayBlockingQueue`）以及锁机制。 6. **Lock和AQS**：Lock接口提供了比`synchronized`更灵活的锁机制，而...
A-JUC-JVM-Java并发知识..pdf
06-05
Java并发编程包（java.util.concurrent，简称JUC）封装了大量用于高并发编程的工具类和接口，其中涉及了线程池、阻塞队列、同步器、原子操作类等。在并发环境下，可以有效降低线程创建和管理的复杂性。 #### Java...
java Queue中 remove/poll, add/offer, element/peek区别
JackyLau的专栏
01-06 7万+
这里简单对其重复的方法做点简单的区分。 offer，add区别： 一些队列有大小限制，因此如果想在一个满的队列中加入一个新项，多出的项就会被拒绝。 这时新的 offer 方法就可以起作用了。它不是对调用 add() 方法抛出一个 unchecked 异常，而只是得到由 offer() 返回的 false。    poll，remove区别： remove() 和 poll() 方法都是
【Java核心技术】 JUC包中队列
Franco的博客
11-24 875
有时候我们把并发包下面的所有容器都习惯叫作并发容器，但是严格来讲，类似 ConcurrentLinkedQueue 这种“Concurrent*”容器，才是真正代表并发。 关于问题中它们的区别： Concurrent 类型基于 lock-free，在常见的多线程访问场景，一般可以提供较高吞吐量。 LinkedBlockingQueue 内部则是基于锁，并提供了 BlockingQueue 的...
用BlockingQueue实现一个简单的生产者-消费者模型
haihongazar的博客
11-02 341
package kevin;      import java.util.concurrent.ArrayBlockingQueue;   import java.util.concurrent.BlockingQueue;   import java.util.concurrent.TimeUnit;      /**   * 一个简单的生产者-消费者demo   *    *
JUC多线程及高并发7-----CAS
ABU_MOlI_ITUI的博客
12-04 5180
面试题笔记2 问题1，CAS底层原理？ 1，自旋锁 2，UnSafe理解 首先要知道用getAndIncrement();这一个方法就可以代替synchronized，也能保证原子性 atomicInteger.getAndIncrement(); 1.Unsafe 是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地（n...
java学习系列-高并发33:学会使用JUC中常见的集合，常看看！
星之宇的博客
08-16 263
JUC集合框架图 图可以看到，JUC的集合框架也是从Map、List、Set、Queue、Collection等超级接口中继承而来的。所以，大概可以知道JUC下的集合包含了一一些基本操作，并且变得线程安全。 Map ConcurrentHashMap 功能和HashMap基本一致，内部使用红黑树实现的。 特性： 迭代结果和存入顺序不一致 key和value都不能为空 线程安全的 ConcurrentSkipListMap 内部使用跳表实现的，放入的元素会进行排序，排序算法支持2种方式来指定： 通
JUC学习系列十一（并发类容器）
qq_38872310的博客
07-27 787
首先了解一下并发类容器和同步类容器的概念，以及这两类的区别： 一、同步类容器 同步类容器都是线程安全的，但在某些场景下可能需要加锁来保护复合操作。复合类操作如：迭代(反复访问元素，遍历完容器中的所有元素)、跳转(根据指定的顺序找到当前元素的下一个元素)、以及条件运算。这些复合操作在多线程并发的修改容器时，可能会表现出意外的行为，最经典的便是ConcurrentModificationExcep...
[java并发] java高并发系列 - 第26天：学会使用JUC中常见的结合，常看看
Aran_的博客
06-17 258
原文链接：查看原文 感谢公众号“ 路人甲Java”的分享，如有冒犯，请联系删除，快去关注他吧 本文内容： 了解JUC常见集合，学会使用 ConcurrentHashMap ConcurrentSkipListMap ConcurrentSkipListSet CopyOnWriteArraySet 介绍Queue接口 ConcurrentLinkedQueue CopyOnWriteArrayList 介绍Deque接口 ConcurrentLinkedDequeue ...
JUC多线程及高并发10---集合类不安全
ABU_MOlI_ITUI的博客
12-09 5404
集合类不安全之并发修改异常 问题：我们知道ArrayList是线程不安全，请编码写一个不安全的案例并给出解决方案。 package ArrayList; import java.util.ArrayList; /* * 集合类不安全的问题 * ArrayList * */ public class ContainerNotSafeDemo { public static void...
【细谈Java并发】谈谈LinkedBlockingQueue
热门推荐
颤抖吧腿子
10-26 12万+
最近在看concurrent包的知识，看到LinkedBlockingQueue，发现一篇好文推荐给大家。 原文地址：【细谈Java并发】谈谈LinkedBlockingQueue 1、简介 上篇我们介绍了ArrayBlockingQueue的相关方法的原理，这一篇我们来学习一下ArrayBlockingQueue的“亲戚” LinkedBlockingQueue。在集合框架里，想必大家都用过Ar...
Java并发编程：掌握JUC线程池的关键知识点
本文主要探讨了Java并发编程中的JUC线程池，强调了掌握并发编程和线程池对于现代软件开发的重要性。线程池通过有效地管理线程资源，降低了资源消耗，提高了响应速度和线程的可管理性。 1. 为什么要有线程池？ ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值