ConcurrentHashMap
线程安全且高效的HashMap
(1)线程不安全的HashMap
在多线程环境下,使用HashMap进行put操作会程会导致HashMap的Entry链表形成环形数据结构,一旦形成环形数据结构,Entry的next节点永远不为空,就会产生死循环获取Entry,导致CPU利用率接近100%,所以在并发情况下不能使用HashMap。
(2)效率低下的HashTable
HashTable容器使用synchronized来保证线程安全,但在线程竞争激烈的情况下HashTable的效率非常低下。因为当一个线程访问HashTable的同步方法,其他线程也访问HashTable的同步方法时,会进入阻塞或轮询状态。如线程1使用put进行元素添加,线程2不但不能使用put方法添加元素,也不能使用get方法来获取元素,所以竞争越激烈效率越低。
(3)ConcurrentHashMap的锁分段技术可有效提升并发访问率
HashTable容器在竞争激烈的并发环境下表现出效率低下的原因是所有访问HashTable的线程都必须竞争同一把锁,假如容器里有多把锁,每一把锁用于锁容器其中一部分数据,那么当多线程访问容器里不同数据段的数据时,线程间就不会存在锁竞争,从而可以有效提高并发访问效率,这就是ConcurrentHashMap所使用的锁分段技术。首先将数据分成一段一段地存储,然后给每一段数据配一把锁,当一个线程占用锁访问其中一个段数据的时候,其他段的数据也能被其他线程访问。
ConcurrentHashMap的结构 JDK1.7
数据结构
jdk1.7中采用Segment + HashEntry
的方式进行实现,结构如下
ConcurrentHashMap
初始化时,计算出Segment
数组的大小ssize
和每个Segment
中HashEntry
数组的大小cap
,并初始化Segment
数组的第一个元素;其中ssize
大小为2的幂次方,默认为16,cap
大小也是2的幂次方,最小值为2,最终结果根据根据初始化容量initialCapacity进行计算,计算过程如下:
if (c * ssize < initialCapacity)
++c;
int cap = MIN_SEGMENT_TABLE_CAPACITY;
while (cap < c)
cap <<= 1;
其中Segment
在实现上继承了ReentrantLock
,这样就自带了锁的功能。
put实现
当执行put
方法插入数据时,根据key的hash值,在Segment
数组中找到相应的位置,如果相应位置的Segment
还未初始化,则通过CAS进行赋值,接着执行Segment
对象的put方法通过加锁机制插入数据,实现如下:
场景:线程A和线程B同时执行相同Segment
对象的put方法
1、线程A执行tryLock()
方法成功获取锁,则把HashEntry
对象插入到相应的位置;
2、线程B获取锁失败,则执行scanAndLockForPut()
方法,在scanAndLockForPut
方法中,会通过重复执行tryLock()
方法尝试获取锁,在多处理器环境下,重复次数为64,单处理器重复次数为1,当执行tryLock()
方法的次数超过上限时,则执行lock()
方法挂起线程B;
3、当线程A执行完插入操作时,会通过unlock()
方法释放锁,接着唤醒线程B继续执行;
size实现
因为ConcurrentHashMap
是可以并发插入数据的,所以在准确计算元素时存在一定的难度,一般的思路是统计每个Segment
对象中的元素个数,然后进行累加,但是这种方式计算出来的结果并不一样的准确的,因为在计算后面几个Segment
的元素个数时,已经计算过的Segment
同时可能有数据的插入或则删除,在1.7的实现中,采用了如下方式:
try {
for (;;) {
if (retries++ == RETRIES_BEFORE_LOCK) {
for (int j = 0; j < segments.length; ++j)
ensureSegment(j).lock(); // force creation
}
sum = 0L;
size = 0;
overflow = false;
for (int j = 0; j < segments.length; ++j) {
Segment<K,V> seg = segmentAt(segments, j);
if (seg != null) {
sum += seg.modCount;
int c = seg.count;
if (c < 0 || (size += c) < 0)
overflow = true;
}
}
if (sum == last)
break;
last = sum;
}
} finally {
if (retries > RETRIES_BEFORE_LOCK) {
for (int j = 0; j < segments.length; ++j)
segmentAt(segments, j).unlock();
}
}
先采用不加锁的方式,连续计算元素的个数,最多计算3次:
1、如果前后两次计算结果相同,则说明计算出来的元素个数是准确的;
2、如果前后两次计算结果都不同,则给每个Segment
进行加锁,再计算一次元素的个数
ConcurrentHashMap的结构 JDK1.8
数据结构
1.8中放弃了Segment
臃肿的设计,取而代之的是采用Node + CAS + Synchronized
来保证并发安全进行实现,结构如下:
只有在执行第一次put方法时才会调用initTable()初始化Node数组,实现如下:
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
if ((sc = sizeCtl) < 0)
Thread.yield(); // lost initialization race; just spin
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
if ((tab = table) == null || tab.length == 0) {
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}
put实现
当执行put
方法插入数据时,根据key的hash值,在Node数组
中找到相应的位置,实现如下:
1、如果相应位置的Node还未初始化,则通过CAS插入相应的数据;
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
2、如果相应位置的Node
不为空,且当前该节点不处于移动状态,则对该节点加synchronized
锁,如果该节点的hash
不小于0,则遍历链表更新节点或插入新节点;
if (fh >= 0) {
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
K ek;
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
if (!onlyIfAbsent)
e.val = value;
break;
}
Node<K,V> pred = e;
if ((e = e.next) == null) {
pred.next = new Node<K,V>(hash, key, value, null);
break;
}
}
}
3、如果该节点是TreeBin
类型的节点,说明是红黑树结构,则通过putTreeVal
方法往红黑树中插入节点;
else if (f instanceof TreeBin) {
Node<K,V> p;
binCount = 2;
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key, value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
4、如果binCount
不为0,说明put
操作对数据产生了影响,如果当前链表的个数达到8个,则通过treeifyBin
方法转化为红黑树,如果oldVal
不为空,说明是一次更新操作,没有对元素个数产生影响,则直接返回旧值;
if (binCount != 0) {
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
5、如果插入的是一个新节点,则执行addCount()
方法尝试更新元素个数baseCount
;
size实现
1.8中使用一个volatile
类型的变量baseCount
记录元素的个数,当插入新数据或则删除数据时,会通过addCount()
方法更新baseCount
,实现如下:
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
CounterCell a; long v; int m;
boolean uncontended = true;
if (as == null || (m = as.length - 1) < 0 ||
(a = as[ThreadLocalRandom.getProbe() & m]) == null ||
!(uncontended =
U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
fullAddCount(x, uncontended);
return;
}
if (check <= 1)
return;
s = sumCount();
}
1、初始化时counterCells
为空,在并发量很高时,如果存在两个线程同时执行CAS修改baseCount值,则失败的线程会继续执行方法体中的逻辑,使用CounterCell
记录元素个数的变化;
2、如果CounterCell
数组counterCells
为空,调用fullAddCount()
方法进行初始化,并插入对应的记录数,通过CAS
设置cellsBusy字段,只有设置成功的线程才能初始化CounterCell
数组,实现如下:
else if (cellsBusy == 0 && counterCells == as &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean init = false;
try { // Initialize table
if (counterCells == as) {
CounterCell[] rs = new CounterCell[2];
rs[h & 1] = new CounterCell(x);
counterCells = rs;
init = true;
}
} finally {
cellsBusy = 0;
}
if (init)
break;
}
3、如果通过CAS
设置cellsBusy字段失败的话,则继续尝试通过CAS
修改baseCount字段,如果修改baseCount
字段成功的话,就退出循环,否则继续循环插入CounterCell
对象;
else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))
break;
所以在1.8中的size
实现比1.7简单多,因为元素个数保存baseCount
中,部分元素的变化个数保存在CounterCell
数组中,实现如下:
public int size() {
long n = sumCount();
return ((n < 0L) ? 0 :
(n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
(int)n);
}
final long sumCount() {
CounterCell[] as = counterCells; CounterCell a;
long sum = baseCount;
if (as != null) {
for (int i = 0; i < as.length; ++i) {
if ((a = as[i]) != null)
sum += a.value;
}
}
return sum;
}
通过累加baseCount
和CounterCell
数组中的数量,即可得到元素的总个数;
并发队列
在并发编程中,有时候需要使用线程安全的队列。如果要实现一个线程安全的队列有两种方式:一种是使用阻塞算法
,另一种是使用非阻塞算法
。使用阻塞算法
的队列可以用一个锁(入队和出队用同一把锁)或两个锁(入队和出队用不同的锁)等方式来实现。非阻塞
的实现方式则可以使用循环CAS的方式来实现。本
非阻塞队列 ConcurrentLinkedQueue
ConcurrentLinkedQueue
是一个基于链接节点的无界线程安全队列,它采用先进先出的规则对节点进行排序,当我们添加一个元素的时候,它会添加到队列的尾部;当我们获取一个元素时,它会返回队列头部的元素。它采用了“wait-free”算法(即CAS算法)来实现
ConcurrentLinkedQueue的数据结构
ConcurrentLinkedQueue由head节点和tail节点组成,每个节点(Node)由节点元素(item)和指向下一个节点(next)的引用组成,节点与节点之间就是通过这个next关联起来,从而组成一张链表结构的队列。默认情况下head节点存储的元素为空,tail节点等于head节点
。
private transient volatile Node<E> tail = head;
入队列
入队列的过程
入队列就是将入队节点添加到队列的尾部。
为了方便理解入队时队列的变化,以及head节点和tail节点的变化,这里以一个示例来展开介绍。假设我们想在一个队列中依次插入4个节点,为了帮助大家理解,每添加一个节点就做了一个队列的快照图,如图6-4所示。图6-4所示的过程如下。
·添加元素1。队列更新head节点的next节点为元素1节点。又因为tail节点默认情况下等于
head节点,所以它们的next节点都指向元素1节点。
·添加元素2。队列首先设置元素1节点的next节点为元素2节点,然后更新tail节点指向元素
2节点。
·添加元素3,设置tail节点的next节点为元素3节点。
·添加元素4,设置元素3的next节点为元素4节点,然后将tail节点指向元素4节点。
通过调试入队过程并观察head节点和tail节点的变化,发现入队主要做两件事情:第一是将入队节点设置成当前队列尾节点的下一个节点
;第二是更新tail节点,如果tail节点的next节点不为空,则将入队节点设置成tail节点,如果tail节点的next节点为空,则将入队节点设置成tail的next节点
,所以tail节点不总是尾节点(理解这一点对于我们研究源码会非常有帮助)。
通过对上面的分析,我们从单线程入队的角度理解了入队过程,但是多个线程同时进行入队的情况就变得更加复杂了,因为可能会出现其他线程插队的情况。如果有一个线程正在入队,那么它必须先获取尾节点,然后设置尾节点的下一个节点为入队节点,但这时可能有另外一个线程插队了,那么队列的尾节点就会发生变化,这时当前线程要暂停入队操作,然后重新获取尾节点。让我们再通过源码来详细分析一下它是如何使用CAS算法来入队的。
public boolean offer(E e) {
if (e == null) throw new NullPointerException();
// 入队前,创建一个入队节点
Node<E> n = new Node<E>(e);
retry:
// 死循环,入队不成功反复入队。
for (;;) {
// 创建一个指向tail节点的引用
Node<E> t = tail;
// p用来表示队列的尾节点,默认情况下等于tail节点。
Node<E> p = t;
for (int hops = 0; ; hops++) {
// 获得p节点的下一个节点。
Node<E> next = succ(p);
// next节点不为空,说明p不是尾节点,需要更新p后在将它指向next节点
if (next != null) {
// 循环了两次及其以上,并且当前节点还是不等于尾节点
if (hops > HOPS && t != tail)
continue retry;
p = next;
}
// 如果p是尾节点,则设置p节点的next节点为入队节点。
else if (p.casNext(null, n)) {
/*如果tail节点有大于等于1个next节点,则将入队节点设置成tail节点,
更新失败了也没关系,因为失败了表示有其他线程成功更新了tail节点*/
if (hops >= HOPS)
casTail(t, n); // 更新tail节点,允许失败
return true;
}
// p有next节点,表示p的next节点是尾节点,则重新设置p节点
else {
p = succ(p);
}
}
}
}
从源代码角度来看,整个入队过程主要做两件事情:第一是定位出尾节点
;第二是使用
CAS
算法将入队节点设置成尾节点的next节点,如不成功则重试。
定位尾节点
tail节点并不总是尾节点,所以每次入队都必须先通过tail节点来找到尾节点。尾节点可能是tail节点,也可能是tail节点的next节点。代码中循环体中的第一个if就是判断tail是否有next节点,有则表示next节点可能是尾节点。获取tail节点的next节点需要注意的是p节点等于p的next节点的情况,只有一种可能就是p节点和p的next节点都等于空,表示这个队列刚初始化,正准备添加节点,所以需要返回head节点。获取p节点的next节点代码如下
final Node<E> succ(Node<E> p) {
Node<E> next = p.getNext();
return (p == next) head : next;
}
设置入队节点为尾节点
p.casNext(null,n)
方法用于将入队节点设置为当前队列尾节点的next节点,如果p是null,表示p是当前队列的尾节点,如果不为null,表示有其他线程更新了尾节点,则需要重新获取当前队列的尾节点。
HOPS的设计意图
上面分析过对于先进先出的队列入队所要做的事情是将入队节点设置成尾节点,doug lea写的代码和逻辑还是稍微有点复杂。那么,我用以下方式来实现是否可行?
public boolean offer(E e) {
if (e == null)
throw new NullPointerException();
Node<E> n = new Node<E>(e);
for (;;) {
Node<E> t = tail;
if (t.casNext(null, n) && casTail(t, n)) {
return true;
}
}
}
让tail
节点永远作为队列的尾节点,这样实现代码量非常少,而且逻辑清晰和易懂。但是,这么做有个缺点,每次都需要使用循环CAS
更新tail
节点。如果能减少CAS
更新tail
节点的次数,就能提高入队的效率,所以doug lea使用hops
变量来控制并减少tail
节点的更新频率,并不是每次节点入队后都将tail
节点更新成尾节点,而是当tail
节点和尾节点的距离大于等于常量HOPS
的值(默认等于1)时才更新tail
节点,tail
和尾节点的距离越长,使用CAS
更新tail
节点的次数就会越少,但是距离越长带来的负面效果就是每次入队时定位尾节点的时间就越长,因为循环体需要多循环一次来定位出尾节点,但是这样仍然能提高入队的效率,因为从本质上来看它通过增加对volatile
变量的读操作来减少对volatile
变量的写操作,而对volatile
变量的写操作开销要远远大于读操作,所以入队效率会有所提升。
private static final int HOPS = 1;
出队列
出队列的就是从队列里返回一个节点元素,并清空该节点对元素的引用。让我们通过每个节点出队的快照来观察一下head节点的变化,如图6-5所示。
从图中可知,并不是每次出队时都更新head
节点,当head
节点里有元素时,直接弹出head
节点里的元素,而不会更新head
节点。只有当head
节点里没有元素时,出队操作才会更新head
节点。这种做法也是通过hops
变量来减少使用CAS
更新head
节点的消耗,从而提高出队效率。让我们再通过源码来深入分析下出队过程。
public E poll() {
Node<E> h = head;
// p表示头节点,需要出队的节点
Node<E> p = h;
for (int hops = 0;; hops++) {
// 获取p节点的元素
E item = p.getItem();
// 如果p节点的元素不为空,使用CAS设置p节点引用的元素为null,
// 如果成功则返回p节点的元素。
if (item != null && p.casItem(item, null)) {
if (hops >= HOPS) {
// 将p节点下一个节点设置成head节点
Node<E> q = p.getNext();
updateHead(h, (q != null) q : p);
}
return item;
}
// 如果头节点的元素为空或头节点发生了变化,这说明头节点已经被另外
// 一个线程修改了。那么获取p节点的下一个节点
Node<E> next = succ(p);
// 如果p的下一个节点也为空,说明这个队列已经空了
if (next == null) {
// 更新头节点。
updateHead(h, p);
break;
}
// 如果下一个元素不为空,则将头节点的下一个节点设置成头节点
p = next;
}
return null;
}
首先获取头节点的元素,然后判断头节点元素是否为空,如果为空,表示另外一个线程已经进行了一次出队操作将该节点的元素取走,如果不为空,则使用CAS
的方式将头节点的引用设置成null
,如果CAS
成功,则直接返回头节点的元素,如果不成功,表示另外一个线程已经进行了一次出队操作更新了head
节点,导致元素发生了变化,需要重新获取头节点。
阻塞队列 BlockingQueue
什么是阻塞队列
阻塞队列(BlockingQueue)
是一个支持两个附加操作的队列。这两个附加的操作支持阻塞的插入和移除方法。阻塞队列常用于生产者和消费者的场景,生产者是向队列里添加元素的线程,消费者是从队列里取元素的线程。阻塞队列就是生产者用来存放元素、消费者用来获取元素的容器
1)支持阻塞的插入
方法:意思是当队列满时,队列会阻塞插入元素的线程,直到队列不满。
2)支持阻塞的移除
方法:意思是在队列为空时,获取元素的线程会等待队列变为非空。
抛出异常
:当队列满时,如果再往队列里插入元素,会抛出IllegalStateException(“Queuefull”)异常。当队列空时,从队列里获取元素会抛出NoSuchElementException异常。返回特殊值
:当往队列插入元素时,会返回元素是否插入成功,成功返回true。如果是移除方法,则是从队列里取出一个元素,如果没有则返回null。一直阻塞
:当阻塞队列满时,如果生产者线程往队列里put元素,队列会一直阻塞生产者线程,直到队列可用或者响应中断退出。当队列空时,如果消费者线程从队列里take元素,队列会阻塞住消费者线程,直到队列不为空。超时退出
:当阻塞队列满时,如果生产者线程往队列里插入元素,队列会阻塞生产者线程一段时间,如果超过了指定的时间,生产者线程就会退出。这两个附加操作的4种处理方式不方便记忆,所以我找了一下这几个方法的规律。put和take分别尾首含有字母t,offer和poll都含有字母o。
备注
:如果是无界阻塞队列,队列不可能会出现满的情况,所以使用put或offer方法永远不会被阻塞,而且使用offer方法时,该方法永远返回true。
Java里的阻塞队列
名称 | 描述 | 是否有界 |
---|---|---|
ArrayBlockingQueue | 一个由数组结构组成的有界阻塞队列。 | 有界 |
LinkedBlockingQueue | 一个由链表结构组成的有界阻塞队列。 | 有界 |
PriorityBlockingQueue | 一个支持优先级排序的无界阻塞队列。 | 无界 |
DelayQueue | 一个使用优先级队列实现的无界阻塞队列。 | 无界 |
SynchronousQueue | 一个不存储元素的阻塞队列。 | |
LinkedTransferQueue一个由链表结构组成的无界阻塞队列。 | 无界 | |
LinkedBlockingDeque | 一个由链表结构组成的双向阻塞队列。 |
ArrayBlockingQueue
ArrayBlockingQueue
是一个用数组实现的有界阻塞队列。此队列按照先进先出(FIFO)的原则对元素进行排序。
默认情况下不保证线程公平的访问队列,所谓公平访问队列是指阻塞的线程,可以按照阻塞的先后顺序访问队列,即先阻塞线程先访问队列。非公平性是对先等待的线程是非公平的,当队列可用时,阻塞的线程都可以争夺访问队列的资格,有可能先阻塞的线程最后才访问队列。为了保证公平性,通常会降低吞吐量。我们可以使用以下代码创建一个公平的阻塞队列。
ArrayBlockingQueue fairQueue = new ArrayBlockingQueue(1000,true);//true 公平队列
访问者的公平性是使用可重入锁实现的,代码如下。
public ArrayBlockingQueue(int capacity, boolean fair) {
if (capacity <= 0)
throw new IllegalArgumentException();
this.items = new Object[capacity];
lock = new ReentrantLock(fair);
notEmpty = lock.newCondition();
notFull = lock.newCondition();
}
LinkedBlockingQueue
LinkedBlockingQueue是一个用链表实现的有界阻塞队列。此队列的默认和最大长度为Integer.MAX_VALUE。此队列按照先进先出的原则对元素进行排序。
PriorityBlockingQueue
PriorityBlockingQueue是一个支持优先级的无界阻塞队列。默认情况下元素采取自然顺序升序排列。也可以自定义类实现compareTo()方法来指定元素排序规则,或者初始化PriorityBlockingQueue时,指定构造参数Comparator来对元素进行排序。需要注意的是不能保证同优先级元素的顺序。
DelayQueue
DelayQueue
是一个支持延时获取元素的无界阻塞队列。队列使用PriorityQueue
来实现。队列中的元素必须实现Delayed
接口,在创建元素时可以指定多久才能从队列中获取当前元素。只有在延迟期满时才能从队列中提取元素。
DelayQueue
非常有用,可以将DelayQueue
运用在以下应用场景。
·缓存系统的设计:可以用DelayQueue
保存缓存元素的有效期,使用一个线程循环查询DelayQueue
,一旦能从DelayQueue
中获取元素时,表示缓存有效期到了。
·定时任务调度:使用DelayQueue
保存当天将会执行的任务和执行时间,一旦从DelayQueue
中获取到任务就开始执行,比如TimerQueue
就是使用DelayQueue
实现的。
如何实现Delayed
接口
DelayQueue
队列的元素必须实现Delayed
接口。我们可以参考ScheduledThreadPoolExecutor
里ScheduledFutureTask
类的实现,一共有三步。
第一步:在对象创建的时候,初始化基本数据。使用time
记录当前对象延迟到什么时候可以使用,使用sequenceNumber
来标识元素在队列中的先后顺序。代码如下。
private static final AtomicLong sequencer = new AtomicLong(0);
ScheduledFutureTask(Runnable r, V result, long ns, long period) {
ScheduledFutureTask(Runnable r, V result, long ns, long period) {
super(r, result);
this.time = ns;
this.period = period;
this.sequenceNumber = sequencer.getAndIncrement();
}
第二步:实现getDelay
方法,该方法返回当前元素还需要延时多长时间,单位是纳秒,代码如下
public long getDelay(TimeUnit unit) {
return unit.convert(time - now(), TimeUnit.NANOSECONDS);
}
通过构造函数可以看出延迟时间参数ns
的单位是纳秒,自己设计的时候最好使用纳秒,因为实getDelay()
方法时可以指定任意单位,一旦以秒或分作为单位,而延时时间又精确不到纳秒就麻烦了。使用时请注意当time小于当前时间时,getDelay
会返回负数。
第三步:实现compareTo
方法来指定元素的顺序。例如,让延时时间最长的放在队列的末尾。实现代码如下。
public int compareTo(Delayed other) {
if (other == this) // compare zero ONLY if same object
return 0;
if (other instanceof ScheduledFutureTask) {
ScheduledFutureTask<> x = (ScheduledFutureTask<>)other;
long diff = time - x.time;
if (diff < 0)
return -1;
else if (diff > 0)
return 1;
else if (sequenceNumber < x.sequenceNumber)
return -1;
else
return 1;
}
long d = (getDelay(TimeUnit.NANOSECONDS) -
other.getDelay(TimeUnit.NANOSECONDS));
return (d == 0) 0 : ((d < 0) -1 : 1);
}
如何实现延时阻塞队列
延时阻塞队列的实现很简单,当消费者从队列里获取元素时,如果元素没有达到延时时间,就阻塞当前线程。
long delay = first.getDelay(TimeUnit.NANOSECONDS);
if (delay <= 0)
return q.poll();
else if (leader != null)
available.await();
else {
Thread thisThread = Thread.currentThread();
leader = thisThread;
try {
available.awaitNanos(delay);
} finally {
if (leader == thisThread)
leader = null;
}
}
代码中的变量leader
是一个等待获取队列头部元素的线程。如果leader
不等于空,表示已经有线程在等待获取队列的头元素。所以,使用await()
方法让当前线程等待信号。如果leader
等于空,则把当前线程设置成leader
,并使用awaitNanos()
方法让当前线程等待接收信号或等待delay
时间。
SynchronousQueue
SynchronousQueue
是一个不存储元素的阻塞队列。每一个put操作必须等待一个take操作,否则不能继续添加元素。
它支持公平访问队列。默认情况下线程采用非公平性策略访问队列。使用以下构造方法可以创建公平性访问的SynchronousQueue
,如果设置为true
,则等待的线程会采用先进先出的顺序访问队列。
public SynchronousQueue(boolean fair) {
transferer = fair new TransferQueue() : new TransferStack();
}
SynchronousQueue
可以看成是一个传球手,负责把生产者线程处理的数据直接传递给消费者线程。队列本身并不存储任何元素,非常适合传递性场景。SynchronousQueue
的吞吐量高于
LinkedBlockingQueue
和ArrayBlockingQueue
。
LinkedTransferQueue
LinkedTransferQueue
是一个由链表结构组成的无界阻塞TransferQueue
队列。相对于其他阻
塞队列,LinkedTransferQueue
多了tryTransfer
和transfer
方法。
(1)transfer
方法
如果当前有消费者正在等待接收元素(消费者使用take
()方法或带时间限制的poll
()方法时)transfer
方法可以把生产者传入的元素立刻transfer
(传输)给消费者。如果没有消费者在等待接收元素,transfer
方法会将元素存放在队列的tail
节点,并等到该元素被消费者消费了才返回。transfer
方法的关键代码如下。
Node pred = tryAppend(s, haveData);
return awaitMatch(s, pred, e, (how == TIMED), nanos);
第一行代码是试图把存放当前元素的s
节点作为tail
节点。第二行代码是让CPU
自旋等待消费者消费元素。因为自旋会消耗CPU
,所以自旋一定的次数后使用Thread
.yield
()方法来暂停当前正在执行的线程,并执行其他线程。
(2)tryTransfer
方法
tryTransfer
方法是用来试探生产者传入的元素是否能直接传给消费者。如果没有消费者等待接收元素,则返回false
。和transfer
方法的区别是tryTransfer
方法无论消费者是否接收,方法立即返回,而transfer
方法是必须等到消费者消费了才返回。对于带有时间限制的tryTransfer
(E
e
,long
timeout
,TimeUnit
unit
)方法,试图把生产者传入
的元素直接传给消费者,但是如果没有消费者消费该元素则等待指定的时间再返回,如果超时还没消费元素,则返回false
,如果在超时时间内消费了元素,则返回true
。’
LinkedBlockingDeque
LinkedBlockingDeque
是一个由链表结构组成的双向阻塞队列。所谓双向队列指的是可以从队列的两端插入和移出元素。双向队列因为多了一个操作队列的入口,在多线程同时入队时,也就减少了一半的竞争。相比其他的阻塞队列,LinkedBlockingDeque
多了addFirst
、addLast
、offerFirst
、offerLast
、peekFirst
和peekLast
等方法,以First
单词结尾的方法,表示插入、
获取(peek
)或移除双端队列的第一个元素。以Last
单词结尾的方法,表示插入、获取或移除双端队列的最后一个元素。另外,插入方法add
等同于addLast
,移除方法remove
等效于removeFirst
。但是take
方法却等同于takeFirst
,不知道是不是JDK
的bug
,使用时还用带有First
和Last
后缀的方法更清楚。
在初始化LinkedBlockingDeque
时可以设置容量防止其过度膨胀。另外,双向阻塞队列可以运用在“工作窃取”模式中。
并发List和set
Vector 和 CopyOnWriteArrayList
在读多写少的高并发环境中,使用
CopyOnWriteArrayList
可以提高系统的性能,但是,在写多读少的场合,CopyOnWriteArrayList
的性能可能不如Vector
。
Vector
或者 CopyOnWriteArrayList
是两个线程安全的List实现,ArrayList 不是线程安全的因此,应该尽量避免在多线程环境中使用ArrayList
。如果因为某些原因必须使用的,则需要使用Collections.synchronizedList(List list)
进行包装。
List list = Collections.synchronizedList(new ArrayList());
...
synchronized (list) {
Iterator i = list.iterator(); // 必须在同步块中
while (i.hasNext())
foo(i.next());
}
CopyOnWriteArrayList
的内部实现与Vector
又有所不同。顾名思义,Copy
-On
-Write
就是 CopyOnWriteArrayList
的实现机制。即当对象进行写操作时,复制该对象;若进行的读操作,则直接返回结果,操作过程中不需要进行同步。
CopyOnWriteArrayList
很好地利用了对象的不变性,在没有对对象进行写操作前,由于对象未发生改变,因此不需要加锁。而在试图改变对象时,总是先获取对象的一个副本,然后对副本进行修改,最后将副本写回。
这种实现方式的核心思想是减少锁竞争,从而提高在高并发时的读取性能,但是它却在一定程度上牺牲了写的性能
。
在 get
() 操作上,Vector
使用了同步关键字,所有的 get
() 操作都必须先取得对象锁才能进行。在高并发的情况下,大量的锁竞争会拖累系统性能。反观CopyOnWriteArrayList
的get
() 实现,并没有任何的锁操作。
/**
/*Vector
*/
public class Vector {
...
public synchronized E get(int index) {
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
return elementData(index);
}
E elementData(int index) {
return (E) elementData[index];
}
...
}
/**
/*Vector
*/
public class CopyOnWriteArrayList {
...
public E get(int index) {
return elementAt(getArray(), index);
}
static <E> E elementAt(Object[] a, int index) {
return (E) a[index];
}
...
}
在 add
() 操作上,CopyOnWriteArrayList
的写操作性能不如Vector
,原因也在于Copy
-On
-Write
。
/**
*CopyOnWriteArrayList
*/
final transient Object lock = new Object();
public boolean add(E e) {
synchronized (lock) {
Object[] es = getArray();
int len = es.length;
es = Arrays.copyOf(es, len + 1);
es[len] = e;
setArray(es);
return true;
}
}
应用
CopyOnWriteArrayList的应用场景本片的主题是并发安全List,所以其主要使用于并发多线程对List有读写操作的场景下。比如有一个流量监控系统,其中有一个功能是要统计今日的访问IP,这显然是一个并发场景,因为同一个时间点可能有多个访问进来,为了保证统计结果的准确行可以考虑使用CopyOnWriteArrayList来存储ip数据:
/**
* @Author: 王琦 <QQ.Eamil>1124602935@qq.com</QQ.Eamil>
* @Date: 2019-4-29 0029 23:04
* @Description: 流量平台IP统计
*/
public class DataMonitorService {
/**
* 流量统计,IP监控列表
*/
private static CopyOnWriteArrayList<String> MONITOR_IP = new CopyOnWriteArrayList();
/**
* 是否在监控中
*/
public static boolean isMonitor(String ip){
return MONITOR_IP.contains(ip) ? true : false;
}
/**
* 获取最新一个ip
*/
public static String lastIp(){
return MONITOR_IP.get(MONITOR_IP.size()-1);
}
/**
* 添加至监控列表
*/
public static void addMonitor(String ip){
if (!isMonitor(ip)) {
MONITOR_IP.add(ip);
}
}
}
代码很简单,但是细心的同学可能会发现上面我们刚刚说过它在写的时候加了锁,性能不能会很差吗,那你这个例子中的流量监控显示是一个发并发场景 + 实时读写的场景,这个怕是不合适吧。嗯,没错,是这样的,是会有性能问题,这也就是它的缺点,但是其可以保证你们的流量统计数据是安全的。
CopyOnWriteArraySet
和List
相似,并发Set
也有一个 CopyOnWriteArraySet
,它实现了 Set
接口,并且是线程安全的。它的内部实现完全依赖于 CopyOnWriteArrayList
,因此,它的特性和 CopyOnWriteArrayList
完全一致,适用于 读多写少的高并发场合,在需要并发写的场合,则可以使用 Set
s
= Collections
.synchronizedSet
(Set
<T
> s
)得到一个线程安全的Set
。
Set s = Collections.synchronizedSet(new HashSet());
...
synchronized (s) {
Iterator i = s.iterator(); // 必须在同步块中
while (i.hasNext())
foo(i.next());
}