0.总述
0.1 同步容器
- Vector 线程安全
- ArrayList 线程不安全
-
- Collections.synchronizedList(ArrayList) 线程安全
- Hashtable 线程安全
- HashMap 线程不安全
-
- Collections.synchronizedMap(HashMap) 线程安全
0.2 并发容器
- CopyOnWriteArrayList 使用起来和ArrayList一样. 每步操作都需要copy,所以耗内存.如果读写操作多,可以用CopyOnWriteArrayList,如果读操作多用同步容器就可以了.
- ConcurrentLinkedQueue
-
- offer 入队列
-
- poll 出队列
- ArrayBlockingQueue put(),take(),add(),remove(),size(),offer();poll();
- ConcurrentHashMap
0.3 阻塞队列
- BlockingQueue
-
- put
-
- take
-
- add
-
- remove
-
- offer
-
- poll
- ArrayBlockingQueue
- LinkedBlockingQueue
1.同步容器
1.1 概述
- Vector 线程安全 用的add方法synchronized,如果是并发编程时也是单线程的.但是当多线程的时候由于有锁,性能降低,所以在并发情况下不会用Vector..
- ArrayList 线程不安全 底层用数组存数据,当添加的数据数目到一定程度,则将当前数据复制到一个更大的新的数组中.
-
- Collections.synchronizedList(ArrayList) 这样安全,最终用的synchronized代码块,并发编程时也是单线程的.
- Hashtable 线程安全,用的put方法synchronized,如果是并发编程时也是单线程的.
- HashMap 线程不安全
-
- Collections.synchronizedMap(HashMap) 这样线程安全,最终也是synchronized代码块,并发编程时也是单线程的.
1.2 示例
1.2.1 Collections.synchronize
public class CollectionThread {
public static void main(String[] args) {
ArrayList<String> s = new ArrayList<>();
//转成线程安全的
List<String> s1 = Collections.synchronizedList(s);
HashMap<String, Object> res = new HashMap<>();
//转成线程安全的
Collections.synchronizedMap(res);
}
}
1.3 同步容器常用API
- Vector 线程安全
- ArrayList 线程不安全
-
- Collections.synchronizedList(ArrayList) 线程安全
- Hashtable 线程安全
- HashMap 线程不安全
-
- Collections.synchronizedMap(HashMap) 线程安全
1.4.源码
1.4.1 Vector
- Vector 方法前有synchronized
package java.util;
public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
}
1.4.2 Hashtable
- Hashtable的put方法前也有synchronized
public class Hashtable<K,V>
extends Dictionary<K,V>
implements Map<K,V>, Cloneable, java.io.Serializable {
public synchronized V put(K key, V value) {
// Make sure the value is not null
if (value == null) {
throw new NullPointerException();
}
// Makes sure the key is not already in the hashtable.
Entry<?,?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
Entry<K,V> entry = (Entry<K,V>)tab[index];
for(; entry != null ; entry = entry.next) {
if ((entry.hash == hash) && entry.key.equals(key)) {
V old = entry.value;
entry.value = value;
return old;
}
}
addEntry(hash, key, value, index);
return null;
}
}
2.并发容器
2.1 CopyOnWriteArrayList
在写的时候copy一份写.
2.1.1 CopyOnWriteArrayList概述
- 添加的数据的时候原数组A复制一份A',添加数据在A'中添加,此过程中读数据从A中读取, 添加完毕后引用指向A',读写都从A'.
- Copy-On-Write简称COW，是一种用于程序设计中的优化策略。其基本思路是，从一开始大家都在共享同一个内容，当某个人想要修改这个内容的时候，才会真正把内容Copy出去形成一个新的内容然后再改，这是一种延时懒惰策略。从JDK1.5开始Java并发包里提供了两个使用CopyOnWrite机制实现的并发容器,它们是CopyOnWriteArrayList和CopyOnWriteArraySet。可以在非常多的并发场景中使用到。
- CopyOnWrite容器即写时复制的容器。通俗的理解是当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。这样做的好处是我们可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。
2.1.2 CopyOnWriteArrayList使用场景
CopyOnWrite并发容器用于读多写少的并发场景。比如白名单，黑名单，商品类目的访问和更新场景，假如我们有一个搜索网站，用户在这个网站的搜索框中，输入关键字搜索内容，但是某些关键字不允许被搜索。这些不能被搜索的关键字会被放在一个黑名单当中，黑名单每天晚上更新一次。当用户搜索时，会检查当前关键字在不在黑名单当中，如果在，则提示不能搜索。实现代码如下：
package com.ifeve.book;
import java.util.Map;
import com.ifeve.book.forkjoin.CopyOnWriteMap;
/**
* 黑名单服务
*
*/
public class BlackListServiceImpl {
private static CopyOnWriteMap<String, Boolean> blackListMap = new CopyOnWriteMap<String, Boolean>(
1000);
public static boolean isBlackList(String id) {
return blackListMap.get(id) == null ? false : true;
}
public static void addBlackList(String id) {
blackListMap.put(id, Boolean.TRUE);
}
/**
* 批量添加黑名单
*
* @param ids
*/
public static void addBlackList(Map<String,Boolean> ids) {
blackListMap.putAll(ids);
}
}
代码很简单，但是使用CopyOnWriteMap需要注意两件事情：
1. 减少扩容开销。根据实际需要，初始化CopyOnWriteMap的大小，避免写时CopyOnWriteMap扩容的开销。
2. 使用批量添加。因为每次添加，容器每次都会进行复制，所以减少添加次数，可以减少容器的复制次数。如使用上面代码里的addBlackList方法。
2.1.3 CopyOnWriteCopyOnWriteArrayList
CopyOnWrite容器有很多优点，但是同时也存在两个问题，即内存占用问题和数据一致性问题。所以在开发的时候需要注意一下。
- 内存占用问题。因为CopyOnWrite的写时复制机制，所以在进行写操作的时候，内存里会同时驻扎两个对象的内存，旧的对象和新写入的对象（注意:在复制的时候只是复制容器里的引用，只是在写的时候会创建新对象添加到新容器里，而旧容器的对象还在使用，所以有两份对象内存）。如果这些对象占用的内存比较大，比如说200M左右，那么再写入100M数据进去，内存就会占用300M，那么这个时候很有可能造成频繁的Yong GC和Full GC。之前我们系统中使用了一个服务由于每晚使用CopyOnWrite机制更新大对象，造成了每晚15秒的Full GC，应用响应时间也随之变长。
针对内存占用问题，可以通过压缩容器中的元素的方法来减少大对象的内存消耗，比如，如果元素全是10进制的数字，可以考虑把它压缩成36进制或64进制。或者不使用CopyOnWrite容器，而使用其他的并发容器，如ConcurrentHashMap。
- 数据一致性问题。CopyOnWrite容器只能保证数据的最终一致性，不能保证数据的实时一致性。所以如果你希望写入的的数据，马上能读到，请不要使用CopyOnWrite容器。
2.1.4 CopyOnWriteArrayList源码
- CopyOnWriteArrayList复制新的存储数组空间.
- 以下代码是向CopyOnWriteArrayList中add方法的实现（向CopyOnWriteArrayList里添加元素），可以发现在添加的时候是需要加锁的，否则多线程写的时候会Copy出N个副本出来。
- 读的时候不需要加锁，如果读的时候有多个线程正在向CopyOnWriteArrayList添加数据，读还是会读到旧的数据，因为写的时候不会锁住旧的CopyOnWriteArrayList。
package java.util.concurrent;
public class CopyOnWriteArrayList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
private transient volatile Object[] array;
//添加,复制一个大一个空间的数组,然后存储并返回
public boolean add(E e) {
//排他锁(独占锁)
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
Object[] newElements = Arrays.copyOf(elements, len + 1);//将原数组复制并+1
newElements[len] = e;
setArray(newElements);
return true;
} finally {
lock.unlock();
}
}
//get的时候不加锁,可以取数据.
public E get(int index) {
return get(getArray(), index);
}
final Object[] getArray() {
return array;
}
final void setArray(Object[] a) {
array = a;
}
private E get(Object[] a, int index) {
return (E) a[index];
}
//删除
public E remove(int index) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
E oldValue = get(elements, index);//取指定索引位置的值
int numMoved = len - index - 1;
if (numMoved == 0)//删的是最后一条数据(len 3,index 2)
setArray(Arrays.copyOf(elements, len - 1));
else {
//如果不是最后一条数据,将该节点前后的数据组成新的数组中的数据
//例:(len 10[0~9],index 3[第4条],numMoved=10-3-1=6[后面还有6条])
Object[] newElements = new Object[len - 1];//9
//取原数组的从0开始复制3个到newElements的0位置开始[即原数组的0~2]
System.arraycopy(elements, 0, newElements, 0, index);
//取原数组的从index4开始复制6个数组到newElements中[即index 3~8]
System.arraycopy(elements, index + 1, newElements, index,numMoved);
setArray(newElements);
}
return oldValue;
} finally {
lock.unlock();
}
}
//设置指定位置值
public E set(int index, E element) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
E oldValue = get(elements, index);
if (oldValue != element) {
int len = elements.length;
//复制一个新数组
Object[] newElements = Arrays.copyOf(elements, len);
//将指定位置的值设置为新数组的并设置为新值
newElements[index] = element;
setArray(newElements);
} else {
// Not quite a no-op; ensures volatile write semantics
setArray(elements);
}
return oldValue;
} finally {
lock.unlock();
}
}
}
package java.util;
public class Arrays {
public static <T> T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());
}
}
- CopyOnWriteMap
import java.util.Collection;
import java.util.Map;
import java.util.Set;
public class CopyOnWriteMap<K, V> implements Map<K, V>, Cloneable {
private volatile Map<K, V> internalMap;
public CopyOnWriteMap() {
internalMap = new HashMap<K, V>();
}
public V put(K key, V value) {
synchronized (this) {
Map<K, V> newMap = new HashMap<K, V>(internalMap);
V val = newMap.put(key, value);
internalMap = newMap;
return val;
}
}
public V get(Object key) {
return internalMap.get(key);
}
public void putAll(Map<? extends K, ? extends V> newData) {
synchronized (this) {
Map<K, V> newMap = new HashMap<K, V>(internalMap);
newMap.putAll(newData);
internalMap = newMap;
}
}
}
2.2 ConcurrentLinkedQueue 无界非阻塞队列,并发链表结构
2.2.1 ConcurrentLinkedQueue概述
常用的并发队列有阻塞队列和非阻塞队列，前者使用锁实现，后者则使用CAS非阻塞算法实现，使用非阻塞队列一般性能比较好,ConcurrentLinkedQueue使用CAS非阻塞算法实现使用CAS解决了当前节点与next节点之间的安全链接和对当前节点值的赋值。由于使用CAS没有使用锁，所以获取size的时候有可能进行offer，poll或者remove操作，导致获取的元素个数不精确，所以在并发情况下size函数不是很有用。另外第一次peek或者first时候会把head指向第一个真正的队列元素。
2.2.2 ConcurrentLinkedQueue类图结构
- 如图ConcurrentLinkedQueue中有两个volatile类型的Node节点分别用来存在列表的首尾节点，其中head节点存放链表第一个item为null的节点，tail则并不是总指向最后一个节点。Node节点内部则维护一个变量item用来存放节点的值，next用来存放下一个节点，从而链接为一个单向无界列表。
public ConcurrentLinkedQueue() {
head = tail = new Node<E>(null);
}
如上代码初始化时候会构建一个item为NULL的空节点作为链表的首尾节点。
2.2.3 offer操作-链表末尾添加一个元素
public boolean offer(E e) {
//e为null则抛出空指针异常
checkNotNull(e);
//构造Node节点构造函数内部调用unsafe.putObject，后面统一讲
final Node<E> newNode = new Node<E>(e);
//从尾节点插入
for (Node<E> t = tail, p = t;;) {
Node<E> q = p.next;
//如果q=null说明p是尾节点则插入
if (q == null) {
//cas插入（1）
if (p.casNext(null, newNode)) {
//cas成功说明新增节点已经被放入链表，然后设置当前尾节点（包含head，1，3，5.。。个节点为尾节点）
if (p != t) // hop two nodes at a time
casTail(t, newNode); // Failure is OK.
return true;
}
// Lost CAS race to another thread; re-read next
}
else if (p == q)//(2)
//多线程操作时候，由于poll时候会把老的head变为自引用，然后head的next变为新head，所以这里需要
//重新找新的head，因为新的head后面的节点才是激活的节点
p = (t != (t = tail)) ? t : head;
else
// 寻找尾节点(3)
p = (p != t && t != (t = tail)) ? t : q;
}
}
2.2.4 add操作-链表末尾添加一个元素
其实内部调用的还是offer
public boolean add(E e) {
return offer(e);
}
2.2.5 poll操作-在链表头部获取并且移除一个元素
public E poll() {
restartFromHead:
//死循环
for (;;) {
//死循环
for (Node<E> h = head, p = h, q;;) {
//保存当前节点值
E item = p.item;
//当前节点有值则cas变为null（1）
if (item != null && p.casItem(item, null)) {
//cas成功标志当前节点以及从链表中移除
if (p != h) // 类似tail间隔2设置一次头节点（2）
updateHead(h, ((q = p.next) != null) ? q : p);
return item;
}
//当前队列为空则返回null（3）
else if ((q = p.next) == null) {
updateHead(h, p);
return null;
}
//自引用了，则重新找新的队列头节点（4）
else if (p == q)
continue restartFromHead;
else//(5)
p = q;
}
}
}
final void updateHead(Node<E> h, Node<E> p) {
if (h != p && casHead(h, p))
h.lazySetNext(h);
}
2.2.6 peek操作-获取链表头部一个元素（只读取不移除)
代码与poll类似，只是少了castItem.并且peek操作会改变head指向，offer后head指向哨兵节点，第一次peek后head会指向第一个真的节点元素。
public E peek() {
restartFromHead:
for (;;) {
for (Node<E> h = head, p = h, q;;) {
E item = p.item;
if (item != null || (q = p.next) == null) {
updateHead(h, p);
return item;
}
else if (p == q)
continue restartFromHead;
else
p = q;
}
}
}
2.2.7 size操作-获取当前队列元素个数
获取当前队列元素个数，在并发环境下不是很有用，因为使用CAS没有加锁所以从调用size函数到返回结果期间有可能增删元素，导致统计的元素个数不精确。
public int size() {
int count = 0;
for (Node<E> p = first(); p != null; p = succ(p))
if (p.item != null)
// 最大返回Integer.MAX_VALUE
if (++count == Integer.MAX_VALUE)
break;
return count;
}
//获取第一个队列元素（哨兵元素不算），没有则为null
Node<E> first() {
restartFromHead:
for (;;) {
for (Node<E> h = head, p = h, q;;) {
boolean hasItem = (p.item != null);
if (hasItem || (q = p.next) == null) {
updateHead(h, p);
return hasItem ? p : null;
}
else if (p == q)
continue restartFromHead;
else
p = q;
}
}
}
//获取当前节点的next元素，如果是自引入节点则返回真正头节点
final Node<E> succ(Node<E> p) {
Node<E> next = p.next;
return (p == next) ? head : next;
}
2.2.8 remove操作-如果队列里面存在该元素则删除给元素，如果存在多个则删除第一个，并返回true，否者返回false
public boolean remove(Object o) {
//查找元素为空，直接返回false
if (o == null) return false;
Node<E> pred = null;
for (Node<E> p = first(); p != null; p = succ(p)) {
E item = p.item;
//相等则使用cas值null,同时一个线程成功，失败的线程循环查找队列中其他元素是否有匹配的。
if (item != null &&
o.equals(item) &&
p.casItem(item, null)) {
//获取next元素
Node<E> next = succ(p);
//如果有前驱节点，并且next不为空则链接前驱节点到next,
if (pred != null && next != null)
pred.casNext(p, next);
return true;
}
pred = p;
}
return false;
}
2.2.9 contains操作-判断队列里面是否含有指定对象
判断队列里面是否含有指定对象，由于是遍历整个队列，所以类似size 不是那么精确，有可能调用该方法时候元素还在队列里面，但是遍历过程中才把该元素删除了，那么就会返回false.
public boolean contains(Object o) {
if (o == null) return false;
for (Node<E> p = first(); p != null; p = succ(p)) {
E item = p.item;
if (item != null && o.equals(item))
return true;
}
return false;
}
2.2.10 实现原理总结
//这个原理还是挺难的.需要的时候再细看吧.
package java.util.concurrent;
public class ConcurrentLinkedQueue<E> extends AbstractQueue<E>
implements Queue<E>, java.io.Serializable {
//tail节点
private transient volatile Node<E> tail;
//构造方法
public ConcurrentLinkedQueue() {
head = tail = new Node<E>(null);
}
//入队操作 [offer vt.提供]
/**
* Inserts the specified element at the tail of this queue.
* As the queue is unbounded, this method will never return {@code false}.
*/
public boolean offer(E e) {
checkNotNull(e);
final Node<E> newNode = new Node<E>(e);//待新增节点
//t指向tail节点,p又等于t,第一次及每次来的时候t和p都为空
//tail还是构造方法ConcurrentLinkedQueue的时候的null空节点
for (Node<E> t = tail, p = t;;) {
//q是p的next,第一次来next也为空
//q是p的next,第二次来next指向第一次添加的值.
Node<E> q = p.next;
//第一次的时候为空
if (q == null) {
// p is last node,将待新增节点加入到最后p的next中(检查next为空的时候)
if (p.casNext(null, newNode)) {//添加成功后
// Successful CAS is the linearization point
// for e to become an element of this queue,
// and for newNode to become "live".
// 第三次的是时候,将tail挪到新增节点
if (p != t) // hop two nodes at a time, 第一次进来的时候p和t相等
casTail(t, newNode); // Failure is OK.
return true;
}
// Lost CAS race to another thread; re-read next
}
//不是第一次的时候
//
else if (p == q)
// We have fallen off list. If tail is unchanged, it
// will also be off-list, in which case we need to
// jump to head, from which all live nodes are always
// reachable. Else the new tail is a better bet.
p = (t != (t = tail)) ? t : head;
//第二次的时候q不为空,也不是p==q,那么p != t为false,则走p=q
else
// Check for tail updates after two hops.
p = (p != t && t != (t = tail)) ? t : q;
}
}
//出队列
public E poll() {
}
//内部类Node
private static class Node<E> {
volatile E item;//存储数据,
volatile Node<E> next;//下一个指针.
Node(E item) {
//将当前对象放到Node的item中
UNSAFE.putObject(this, itemOffset, item);
}
private static final sun.misc.Unsafe UNSAFE;
private static final long itemOffset;
private static final long nextOffset;
static {
try {
UNSAFE = sun.misc.Unsafe.getUnsafe();
Class<?> k = Node.class;
itemOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("item"));
nextOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("next"));
} catch (Exception e) {
throw new Error(e);
}
}
}
}
2.2.11 参考文章
√并发队列-无界非阻塞队列ConcurrentLinkedQueue原理探究
无界非阻塞队列 ConcurrentLinkedQueue 原理探究
聊聊并发（六）ConcurrentLinkedQueue的实现原理分析
2.3 ConcurrentHashMap
2.3.1 概述
-
将map中的数据,分区分块(根据hash),然后如果写的时候只对相应的区块来进行操作.
ConcurrentHashMap 和 HashMap 思路是差不多的，但是因为它支持并发操作，所以要复杂一些。 -
整个 ConcurrentHashMap 由一个个 Segment 组成，Segment 代表”部分“或”一段“的意思，所以很多地方都会将其描述为分段锁。注意，行文中，我很多地方用了“槽”来代表一个 segment。
-
简单理解就是，ConcurrentHashMap 是一个 Segment 数组，Segment 通过继承 ReentrantLock 来进行加锁，所以每次需要加锁的操作锁住的是一个 segment，这样只要保证每个 Segment 是线程安全的，也就实现了全局的线程安全。
2.3.2 jdk8的实现原理
JDK8的实现已经抛弃了Segment分段锁机制，利用CAS+Synchronized来保证并发更新的安全，底层依然采用数组+链表+红黑树的存储结构。
2.3.3 变量解释
-
table：默认为null，初始化发生在第一次插入操作，默认大小为16的数组，用来存储Node节点数据，扩容时大小总是2的幂次方。
-
nextTable：默认为null，扩容时新生成的数组，其大小为原数组的两倍。
-
sizeCtl ：默认为0，用来控制table的初始化和扩容操作，具体应用在后续会体现出来。
- -1 代表table正在初始化
- -N 表示有N-1个线程正在进行扩容操作
- 其余情况：
- 1、如果table未初始化，表示table需要初始化的大小。
- 2、如果table初始化完成，表示table的容量，默认是table大小的0.75倍，居然用这个公式算0.75（n - (n >>> 2)）。
-
Node：保存key，value及key的hash值的数据结构。
-
ForwardingNode：一个特殊的Node节点，hash值为-1，其中存储nextTable的引用。只有table发生扩容的时候，ForwardingNode才会发挥作用，作为一个占位符放在table中表示当前节点为null或则已经被移动。
2.3.4 初始化
实例化ConcurrentHashMap时带参数时，会根据参数调整table的大小，假设参数为100，最终会调整成256，确保table的大小总是2的幂次方。
private static final int tableSizeFor(int c) {
int n = c - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
2.3.5 初始化table
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
//如果一个线程发现sizeCtl<0，意味着另外的线程执行CAS操作成功，当前线程只需要让出cpu时间片
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;
}
2.3.6 put操作
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
int hash = spread(key.hashCode());
int binCount = 0;
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
if (tab == null || (n = tab.length) == 0)
tab = initTable();
// table中定位索引位置，n是table的大小
// 如果f为null，说明table中这个位置第一次插入元素，利用Unsafe.compareAndSwapObject方法插入Node节点。
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
// 如果CAS成功，说明Node节点已经插入，随后addCount(1L,binCout)方法会检查当前容量是否需要进行扩容。如果CAS失败，说明有其它线程提前插入了节点，自旋重新尝试在这个位置插入节点。
if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
// 如果f的hash值为-1，说明当前f是ForwardingNode节点，意味有其它线程正在扩容，则一起进行扩容操作。
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
//省略部分代码
}
addCount(1L, binCount);
return null;
}
2.3.7 hash算法
static final int spread(int h) {return (h ^ (h >>> 16)) & HASH_BITS;}
2.3.8 获取table中对应的元素f
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}
Doug Lea采用Unsafe.getObjectVolatile来获取，也许有人质疑，直接table[index]不可以么，为什么要这么复杂？ 在java内存模型中，我们已经知道每个线程都有一个工作内存，里面存储着table的副本，虽然table是volatile修饰的，但不能保证线程每次都拿到table中的最新元素，Unsafe.getObjectVolatile可以直接获取指定内存的数据，保证了每次拿到数据都是最新的。
2.3.9 链表或红黑树操作
其余情况把新的Node节点按链表或红黑树的方式插入到合适的位置，这个过程采用同步内置锁实现并发。
synchronized (f) {
// 在节点f上进行同步，节点插入之前，再次利用tabAt(tab, i) == f判断，防止被其它线程修改。
if (tabAt(tab, i) == f) {
// 如果f.hash >= 0，说明f是链表结构的头结点，遍历链表，如果找到对应的node节点，则修改value，否则在链表尾部加入节点。
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;
}
}
}
// 如果f是TreeBin类型节点，说明f是红黑树根节点，则在树结构上遍历元素，更新或增加节点。
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;
}
}
}
}
// 如果链表中节点数binCount >= TREEIFY_THRESHOLD(默认是8)，则把链表转化为红黑树结构。
if (binCount != 0) {
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
2.3.10 table 扩容
当table容量不足的时候，即table的元素数量达到容量阈值sizeCtl，需要对table进行扩容。
整个扩容分为两部分：
- 构建一个nextTable，大小为table的两倍。
- 把table的数据复制到nextTable中。
这两个过程在单线程下实现很简单，但是ConcurrentHashMap是支持并发插入的，扩容操作自然也会有并发的出现，这种情况下，第二步可以支持节点的并发复制，这样性能自然提升不少，但实现的复杂度也上升了一个台阶。
先看第一步，构建nextTable，毫无疑问，这个过程只能只有单个线程进行nextTable的初始化，具体实现如下：
private final void addCount(long x, int check) {
// 省略部分代码
if (check >= 0) {
Node<K,V>[] tab, nt; int n, sc;
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
int rs = resizeStamp(n);
if (sc < 0) {
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
transfer(tab, nt);
}
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);
s = sumCount();
}
}
}
2.3.11 get操作
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
int h = spread(key.hashCode());
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
else if (eh < 0) // 树
return (p = e.find(h, key)) != null ? p.val : null;
while ((e = e.next) != null) { // 链表
if (e.hash == h &&
((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}
2.3.12 参考文章
Java7/8 中的 HashMap 和 ConcurrentHashMap 全解析 HashMap、Hashtable、ConcurrentHashMap的原理与区别 高并发编程系列：ConcurrentHashMap的实现原理(JDK1.7和JDK1.8)
3.阻塞队列
3.1 BlockingQueue
3.1.1 BlockingQueue概述
BlockingQueue是一个接口， 继承Queue接口，Queue接口继承 Collection,先进先出（FIFO）
3.1.2 BlockingQueue
- put
- take
- add
- remove
- offer
- poll
3.1.3 BlockingQueue源码
public interface BlockingQueue<E> extends Queue<E> {
}
public class ArrayBlockingQueue<E> extends AbstractQueue<E>
implements BlockingQueue<E>, java.io.Serializable {
public ArrayBlockingQueue(int capacity) {
this(capacity, false);
}
}
3.2 ArrayBlockingQueue
3.2.1 ArrayBlockingQueue概述
- 生产者把数据插入的队列的末尾，消费者总是从队列的头部拿数据，当队列满了之后，再往队列中插入数据会造成队列的阻塞，同样，从空的队列中取数据，也是阻塞的。
有一个公平策略，我们如果希望，队列中的数据总是按照生产者生产数据的顺序，取队列中的数据，那么我们可以在构造函数中把fair参数设置为true就可以了，但是这种操作会降低吞吐量。
java.lang.Object
---java.util.AbstractCollection<E>
----java.util.AbstractQueue<E>
------java.util.concurrent.ArrayBlockingQueue<E>
3.2.2 ArrayBlockingQueue源码
package java.util.concurrent;
public class ArrayBlockingQueue<E> extends AbstractQueue<E>
implements BlockingQueue<E>, java.io.Serializable {
** Condition for waiting takes */
private final Condition notEmpty;
/** Condition for waiting puts */
private final Condition notFull;
public void put(E e) throws InterruptedException {
checkNotNull(e);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == items.length)
notFull.await();
enqueue(e);
} finally {
lock.unlock();
}
}
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == 0)
notEmpty.await();
return dequeue();
} finally {
lock.unlock();
}
}
}
3.3 LinkedBlockingQueue
3.3.1 LinkedBlockingQueue概述
-
java.util.concurrent包下的新类。LinkedBlockingQueue就是其中之一，是一个阻塞的线程安全的队列，底层采用链表实现。LinkedBlockingQueue构造的时候若没有指定大小，则默认大小为Integer.MAX_VALUE，当然也可以在构造函数的参数中指定大小。LinkedBlockingQueue不接受nul
-
链表组成的阻塞队列
参考文章
Java集合---ArrayList的实现原理 www.cnblogs.com/ITtangtang/… HashMap的实现原理 www.importnew.com/16301.html
