文章目录

概述
BlockingQueue
ArrayBlockingQueue
- 数据存储相关属性
- 阻塞特性相关属性
- 主要方法
LinkedBlockingQueue
- LinkedBlockingQueue 主要属性
- LinkedBlockingQueue 设计思想
ConcurrentLinkedQueue
PriorityBlockingQueue
- PriorityBlockingQueue 主要属性
- PriorityBlockingQueue 设计思想
SynchronousQueue
LinkedBlockingDeque
DelayQueue
DelayQueue 主要属性
- DelayQueue 主要设计思想
CopyOnWrite
CopyOnWriteArrayList
- CopyOnWriteArrayList 的主要属性
- CopyOnWriteArrayList 主要设计思想
- CopyOnWriteArraySet

概述

常用的并发集合类，主要有 ArrayBlockingQueue，ConcurrentLinkedQueue，LinkedBlockingQueue，PriorityBlockingQueue，DelayQueue，SynchronousQueue，LinkedBlockingDeque，以及 COW 系列的集合，如 CopyOnWriteArrayList，CopyOnWriteArraySet 等

BlockingQueue

BlockingQueue 描述了一个阻塞队列应该有的行为，例如：

阻塞读方法：take()
阻塞写方法：put()

阻塞的读写方法的函数签名上都会抛出 InterruptedException，具体的阻塞逻辑由实现类自行实现。

ArrayBlockingQueue

是一个基于数组实现的阻塞队列，创建对象时必须指定容量

数据存储相关属性

内置了一个循环队列用于存储数据，可以更高效地利用内存空间

    /** The queued items */final Object[] items;/** items index for next take, poll, peek or remove */int takeIndex;/** items index for next put, offer, or add */int putIndex;/** Number of elements in the queue */int count;

阻塞特性相关属性

内置一个 ReentrantLock 锁对象，一个队列是否为空的 Condition 对象，以及一个队列是否满的 Condition 对象

    /** Main lock guarding all access */final ReentrantLock lock;/** Condition for waiting takes */private final Condition notEmpty;/** Condition for waiting puts */private final Condition notFull;

其中，notEmpty 条件和 notFull 条件都是由 lock 对象创建出来的

主要方法

构造方法中必须传入容量，可以通过 public ArrayBlockingQueue(int capacity, boolean fair) 中的 fair 参数来指定公平/非公平模式
- fair 参数最终会用于构造 ReentrantLock 锁对象
put 方法会在队列满的时候（（队尾下标+1）%队列长度=队头下标））调用 notEmpty 条件进行等待，等队列再次有空位的时候（有元素出队时将会被唤醒）将元素放至队尾
take 会在队列为空的时候（队尾下标=队头下标）调用 notFull 条件进行等待，当队列不为空时，将队头的元素返回，并删除队头元素

LinkedBlockingQueue

LinkedBlockingQueue 是一个基于单向链表实现的阻塞队列，其容量为：

如果在构造函数中指定了容量，那么容量就是队列长度的最大边界限制
如果没有在构造函数中指定容量，容量将会默认设置成 Integer.MAX_VALUE，近似无界

所以，LinkedBlockingQueue 在不传入容量的情况下，最大容量会被设置为 Integer.MAX_VALUE

LinkedBlockingQueue 主要属性

    /** The capacity bound, or Integer.MAX_VALUE if none */private final int capacity;/** Current number of elements */private final AtomicInteger count = new AtomicInteger();/*** Head of linked list.* Invariant: head.item == null*/transient Node<E> head;/*** Tail of linked list.* Invariant: last.next == null*/private transient Node<E> last;/** Lock held by take, poll, etc */private final ReentrantLock takeLock = new ReentrantLock();/** Wait queue for waiting takes */private final Condition notEmpty = takeLock.newCondition();/** Lock held by put, offer, etc */private final ReentrantLock putLock = new ReentrantLock();/** Wait queue for waiting puts */private final Condition notFull = putLock.newCondition();

LinkedBlockingQueue 底层的数据结构是单向链表
内置一个读取锁，ReentrantLock takeLock ，以及由这把锁创建出来的非空条件 Condition notEmpty
内置一个写入锁，ReentrantLock putLock，以及由这把锁创建出来的非空条件 Condition notFull

LinkedBlockingQueue 设计思想

执行 take() 方法的时候，会从队列的头部取出元素，所以必须要获取读取锁 takLock，从而确保同时只有一个线程可以操作链表的头部
- 当执行 take() 方法的时候如果队列为空，那么当前线程将会调用 notEmpty.await() 方法进行阻塞，一直到有元素放入事件发生（如调用 put() 方法）
执行 put() 方法的时候，会从队列的尾部添加元素，所以必须要获取到写入锁 putLock，从而确保同时只有一个线程可以操作链表的尾部
- 当执行 put() 方法的时候如果队列满了，那么当前线程将会调用 notFull.await() 方法进行阻塞，一直到有元素取出事件发生（如调用 take() 方法）
当执行 remove()、contains() 等方法时，将会同时获取读、写两把锁，在方法结束后同时释放两把锁
- 这样做的目的是因为 remove() 等方法不能确定在链表的某个位置操作（读取或者新增、删除）元素，所以需要同时对队头和队尾都加锁

总的来说，LinkedBlockingQueue 就是通过控制链表同一方向的操作，来实现线程安全和读写条件阻塞；当不能确定操作元素的位置时，将进行双重加锁

ConcurrentLinkedQueue

ConcurrentLinkedQueue 是一个基于单向链表实现的无界线程安全队列，基于 CAS + 自旋来保证线程安全

PriorityBlockingQueue

PriorityBlockingQueue 是一个基于优先级的无界阻塞队列，底层的数据结构是堆。

PriorityBlockingQueue 主要属性

    /*** Priority queue represented as a balanced binary heap: the two* children of queue[n] are queue[2*n+1] and queue[2*(n+1)].  The* priority queue is ordered by comparator, or by the elements'* natural ordering, if comparator is null: For each node n in the* heap and each descendant d of n, n <= d.  The element with the* lowest value is in queue[0], assuming the queue is nonempty.*/private transient Object[] queue;/*** The number of elements in the priority queue.*/private transient int size;/*** The comparator, or null if priority queue uses elements'* natural ordering.*/private transient Comparator<? super E> comparator;/*** Lock used for all public operations*/private final ReentrantLock lock;/*** Condition for blocking when empty*/private final Condition notEmpty;/*** Spinlock for allocation, acquired via CAS.*/private transient volatile int allocationSpinLock;

PriorityBlockingQueue 底层有一个可扩容的对象数组 Object[] queue，结构是堆
内置一个 ReentrantLock 独占锁，以及由这个锁构造出来的 Condition notEmpty 条件
一个 volatile 关键字修饰的整型变量 volatile int allocationSpinLock

PriorityBlockingQueue 设计思想

所有的存取方法都需要获取锁后才能执行，包括 size() 方法
当数组的长度大于等于容量时，需要进行扩容操作
- 扩容之前先要释放锁
- 首先要尝试使用 CAS 尝试把 allocationSpinLock 变量的值修改为 1
- 当前容量小于 64 时，增长为原来的 2 倍 + 2；否则增长为原来的 1.5 倍
- 还原 allocationSpinLock 的值
- 扩容完成之后，再次获取锁
插入元素时，会按照指定的 Comparator 的比较方法进行插入；否则将会使用元素自身的 Comparable.compareTo() 方法进行比较
调用 take() 方法时如果队列为空时，当前线程将会调用 notEmpty.await() 进行阻塞，直到有新的元素入队后被唤醒
出队的元素始终是堆顶元素

SynchronousQueue

一个不存储元素的阻塞队列，每一个入队操作必须对应一个出队操作，每一个出队操作必须对应一个入队操作。

LinkedBlockingDeque

LinkedBlockingQueue 是一个双端阻塞队列，底层数据结构是双向链表。

内置一个 ReentrantLock 独占锁，以及由这个锁构造出来的 Condition notEmpty（队列为空，等待放入）和 Condition notFull（队列已满，等待取出）条件
当队列为空时调用阻塞取出相关方法（take()）时，将会调用 notEmpty.await() 方法进行阻塞，直到有元素被放入到队列中
当队列已满时调用阻塞存入相关方法（put()）时，将会调用 notFull.await() 方法进行阻塞，直到有元素被取出
可以从队列的两端（头部/尾部）进行元素操作（存入/取出）元素，意味着可以使用 LinkeBlockingQueue 自由实现栈或者队列

DelayQueue

DelayQueue 是一个无界延时阻塞队列。底层的数据结构是优先级队列 PriorityQueue

DelayQueue 主要属性

private final transient ReentrantLock lock = new ReentrantLock();private final PriorityQueue<E> q = new PriorityQueue<E>();private Thread leader = null;/*** Condition signalled when a newer element becomes available* at the head of the queue or a new thread may need to* become leader.*/private final Condition available = lock.newCondition();

内置一个 ReentrantLock 独占锁，以及一个由锁对象创建出来的条件对象 Condition available
底层数据结构是 PriorityQueue，是由堆来实现的
有一个 Thread leader 属性，代表的是当前第一个尝试等待获取队头元素的线程

DelayQueue 主要设计思想

所有放入到 DelayQueue 中的元素，都要实现 Delayed 接口
当队列为空时调用出队方法，将会调用 available.await() 方法进行阻塞，直到有新的元素被添加到队列中
当队列不为空时调用出队方法，首先判断队头元素的剩余过期时间是否小于等于 0
- 如果队头元素的剩余过期时间小于等于 0，那么说明元素已经到期，直接把这个元素移除并返回
- 如果队头元素的剩余过期时间（long delay）大于 0，将会判断当前 leader 是否为空
  - 如果为空，则把自己设置为 leader，并且调用 available.awaitNanos(long delay) 方法，将自己阻塞 long delay 时间
  - 如果不为空，说明已经有其他线程在等待获取元素了，那么将调用 available.await() 方法进行无限期等待
- 在阻塞了 long delay 时间后，重新将 leader 置为 null，并且执行上面的逻辑
所有存取方法调用前都需要获取锁

CopyOnWrite

CopyOnWrite，顾名思义，就是写时复制的意思。
主要的设计思想就是在修改数据的时候，并不直接在原数据上进行修改，而是先拷贝一份原数据的副本，后续对于数据的修改操作在拷贝出来的副本上进行，最后将副本替换掉原数据。
这样做的好处就是，在读取数据的时候，是不用采取任何并发控制手段的，直接访问源数据就行，所以写时复制适用于读多写少的场景。

CopyOnWriteArrayList

CopyOnWriteArrayList 是一个并发安全的动态数组，底层数据结构是数组。

CopyOnWriteArrayList 的主要属性

    /** The lock protecting all mutators */final transient ReentrantLock lock = new ReentrantLock();/** The array, accessed only via getArray/setArray. */private transient volatile Object[] array;

内置一个 ReentrantLock 独占锁
一个用 volatile 关键字修饰的对象数组 array

CopyOnWriteArrayList 主要设计思想

在所有的修改方法执行之前，首先要获取锁
在使用元素添加方法时，每次会拷贝出一个长度 +1 的新数组，同时把要添加的元素放入到新数组的最后一个位置上，最后把旧数组替换成新数组
在使用元素移除方法时，每次会拷贝出一个长度 -1 的新数组，最后根据要删除的元素位置，进行数组拷贝，最后把旧数组替换成新数组
所有读取方法都没有采取任何同步措施，包括获取迭代器
- 获取迭代器的方法，并没有像很多文章中说的对当前数组进行了一个拷贝，而是直接把当前数组的引用传递给了迭代器
- 之所以不用对当前数组进行拷贝，是因为每次的修改方法都会创建出一个新数组，所以 CopyOnWriteArrayList 迭代器根本不会，也没有必要去拷贝当前数组

CopyOnWriteArraySet

CopyOnWriteArraySet 是一个并发安全的无重复集合，底层是基于 CopyOnWriteArrayList 来实现的

常用并发工具类（并发集合类）相关推荐

并发编程 | 并发工具类 - 序章
总览本章节的思维导图如下所示: 引言在并发编程的世界中,我们面临着各种复杂的问题,例如线程间的同步.数据一致性保证.任务的分配与执行等.幸运的是,Java提供了一套强大的并发工具类,帮助我们更好地 ...
JUC 常用 4 大并发工具类
欢迎关注方志朋的博客,回复"666"获面试宝典什么是JUC? JUC就是java.util.concurrent包,这个包俗称JUC,里面都是解决并发问题的一些东西该包的位置位 ...
常用并发工具类（锁和线程间通信工具类）
常用并发工具类总结 JUC 下的常用并发工具类(锁和线程间通信工具类),主要包括 ReentrantLock.ReentrantReadWriteLock.CountDownLatch.CyclicB ...
【重难点】【JUC 02】volitale 常用模式、JUC 下有哪些内容、并发工具类
[重难点][JUC 02]volitale 常用模式 .JUC 下有哪些内容 .并发工具类文章目录 [重难点][JUC 02]volitale 常用模式 .JUC 下有哪些内容 .并发工具类一.v ...
java并发编程中常用的工具类 Executor
/*************************************************** * TODO: description . * @author: gao_chun * ...
15.并发工具类（解析hashtable,ConcurrentHashMap1.7与1.8的区别以及Semaphore）
3. 并发工具类 3.1 并发工具类-Hashtable Hashtable出现的原因:在集合类中HashMap是比较常用的集合对象,但是HashMap在多线程环境下可能会出现线程不安全的情况,为了保 ...
第十章_多线程(2)_线程池原子性并发工具类
目录一.线程池 1 - 线程状态 2 - 线程池 3 - Executors线程池二.Volatile 三.原子性四.并发工具类 1 - 并发工具类-Hashtable 2 - 并发工具类-Co ...
线程池，Volatile，原子性类AtomicInteger，乐观锁悲观锁，并发工具类Hashtable，ConcurrentHashMap类，Semaphore类
目录一.线程的状态二.线程池 1.创建线程池的方式 1.1线程池-Executors默认线程池 1.2线程池-Executors创建指定上限的线程池 1.3线程池-ThreadPoolExec ...
Java多线程系列(九)：CountDownLatch、Semaphore等4大并发工具类详解
之前谈过高并发编程系列:4种常用Java线程锁的特点,性能比较.使用场景 ,以及高并发编程系列:ConcurrentHashMap的实现原理(JDK1.7和JDK1.8) 今天主要介绍concurre ...
【搞定Java并发编程】第24篇：Java中的并发工具类之CountDownLatch
上一篇:Java中的阻塞队列 BlockingQueue 详解本文目录: 1.CountDownLatch的基本概述 2.CountDownLatch的使用案例 3.CountDownLatch的源 ...

常用并发工具类（并发集合类）