并发容器及其原理
锁的使用，相当于对象的修改串行化了，这样保证了线程的安全性，所以这种方法的代价就是严重降低了并发性，当多个线程竞争容器时，吞吐量严重降低。
因此Java5.0开
始针对多线程并发访问设计，提供了并发性能较好的并发容器，引入了java.util.concurrent包。
而为了达到尽可能提高效率的目标，Java源码中采用了多种优化方式来提高并发容器的执行效率或者使用方便性，核心的就是：锁，CAS（无锁），COW（读写分离），分段锁。
下面就逐一结合源码进行详细说明。
————————— 基于 锁 来实现 —————————
生产者-消费者模型的实现，
LinkedBlockingQueue
相对来说，通过锁的方式来实现，是非常典型而传统的多线程协作方法。下面来探讨阻塞队列的实现原理，本文以ArrayBlockingQueue为例，其他阻塞队列实现原理可能和ArrayBlockingQueue有一些差别，但是大体思路应该类似。
首先看一下ArrayBlockingQueue类中的几个成员变量：
|
public class ArrayBlockingQueue
private static final long serialVersionUID = -817911632652898426L;
private final E[] items; /** The queued items */
private int takeIndex; /** items index for next take, poll or remove */
private int putIndex; /** items index for next put, offer, or add. */
private int count; /** Number of items in the queue */
/** Concurrency control uses the classic two-condition algorithm found in any textbook. */
private final ReentrantLock lock; /** Main lock guarding all access */
private final Condition notEmpty; /** Condition for waiting takes */
private final Condition notFull; /** Condition for waiting puts */
}
|
下面看一下ArrayBlockingQueue的构造器，构造器有三个重载版本：
|
public ArrayBlockingQueue(int capacity) {} //只有一个参数用来指定容量
public ArrayBlockingQueue(int capacity, boolean fair) {} / /指定容量和公平性
public ArrayBlockingQueue(int capacity, boolean fair, Collection c) {} //指定容量、公平性以及用另外一个集合进行初始化
|
然后看它的两个关键方法的实现：put()和take()：
|
public void put(E e) throws InterruptedException {
if (e == null) throw new NullPointerException();
final E[] items = this.items;
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
try {
while (count == items.length)
notFull.await();
} catch (InterruptedException ie) {
notFull.signal(); // propagate to non-interrupted thread
throw ie;
}
insert(e);
} finally {
lock.unlock();
}
}
|
从put方法的实现可以看出，它先获取了锁，并且获取的是可中断锁，然后判断当前元素个数是否等于数组的长度，如果相等，则调用notFull.await()进行等待，如果捕获到中断异常，则唤醒线程并抛出异常。
当被其他线程唤醒时，通过insert(e)方法插入元素，最后解锁。
|
|
private void insert(E x) {
items[putIndex] = x;
putIndex = inc(putIndex);
++count;
notEmpty.signal();
}
|
它是一个private方法，插入成功后，通过notEmpty唤醒正在等待取元素的线程。 |
|
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
try {
while (count == 0)
notEmpty.await();
} catch (InterruptedException ie) {
notEmpty.signal(); // propagate to non-interrupted thread
throw ie;
}
E x = extract();
return x;
} finally {
lock.unlock();
}
}
|
跟put方法实现很类似，
只不过put方法等待的是notFull信号，而take方法等待的是notEmpty信号。在take方法中，如果可以取元素，则通过extract方法取得元素，下面是extract方法的实现：
|
|
private E extract() {
final E[] items = this.items;
E x = items[takeIndex];
items[takeIndex] = null;
takeIndex = inc(takeIndex);
--count;
notFull.signal();
return x;
}
|
跟insert方法也很类似。 |
其实从这里大家应该明白了阻塞队列的实现原理，事实它和我们用Object.wait()、Object.notify()和非阻塞队列实现生产者-消费者的思路类似，只不过它把这些工作一起集成到了阻塞队列中实现。
可以看到, 使用阻塞队列代码要简单得多，不需要再单独考虑同步和线程间通信的问题。在并发编程中，一般推荐使用阻塞队列，这样实现可以尽量地避免程序出现意外的错误。
阻塞队列使用最经典的场景就是socket客户端数据的读取和解析，读取数据的线程不断将数据放入队列，然后解析线程不断从队列取数据解析。还有其他类似的场景，只要符合生产者-消费者模型的都可以使用阻塞队列。
————————— 基于 CAS操作 来实现 —————————
1：非阻塞队列 ConcurrentStack
为了更好的理解，先构造一个新数据结构：ConcurrentStack。这是JDK中没有的，但是相对来说结构简单，为理解核心原理提供了一个很好的样例。
|
public class ConcurrentStack
AtomicReference
public void push(E item) {
Node
Node
do {
oldHead = head.get();
newHead.next = oldHead;
} while (! head.compareAndSet(oldHead, newHead));
}
public E pop() {
Node
Node
do {
oldHead = head.get();
if (oldHead == null)
return null;
newHead = oldHead.next;
}
while (! head.compareAndSet(oldHead
, newHead)); //核心代码
return oldHead.item;
}
static class Node
final E item;
Node
public Node(E item) { this.item = item; }
}
}
|
push() 方法观察当前最顶的节点，构建一个新节点放在堆栈上，然后，如果最顶端的节点在初始观察之后没有变化，那么就安装新节点。如果 CAS 失败，意味着另一个线程已经修改了堆栈，那么过程就会重新开始。
在轻度到中度的争用情况下，
非阻塞算法的性能会超越阻塞算法，因为 CAS 的多数时间都在第一次尝试时就成功，而发生争用时的开销也不涉及线程挂起和上下文切换，只多了几个循环迭代。
没有争用的 CAS 要比没有争用的锁便宜得多（这句话肯定是真的，因为没有争用的锁涉及 CAS 加上额外的处理），而争用的 CAS 比争用的锁获取涉及更短的延迟( 但是由于涉及到多次循环, 所以 CPU 成本较高 )。
在高度争用的情况下（即有多个线程不断争用一个内存位置的时候），基于锁的算法开始提供比非阻塞算法更好的吞吐率，因为当线程阻塞时，它就会停止争用，耐心地等候轮到自己，从而避免了进一步争用。但是，这么高的争用程度并不常见。
2: 非阻塞链表 ConcurrentLinkedQueue
对于更复杂的数据结构，
非阻塞算法要比这些简单示例复杂得多，因为修改链表、树或哈希表可能涉及对多个指针的更新。CAS 支持对单一指针的原子性条件更新，但是不支持两个以上的指针。所以，要构建一个非阻塞的链表、树或哈希表，需要找到一种方式，可以用 CAS 更新多个指针，同时不会让数据结构处于不一致的状态。
在链表的尾部插入元素，通常涉及对两个指针的更新：“尾” 指针总是指向列表中的最后一个元素，“下一个” 指针从过去的最后一个元素指向新插入的元素。
因为需要更新两个指针，所以需要两个 CAS。
在独立的 CAS 中更新两个指针带来了两个需要考虑的潜在问题：
如果第一个 CAS 成功，而第二个 CAS 失败，会发生什么？如果其他线程在第一个和第二个 CAS 之间企图访问链表，会发生什么？
对于复杂数据结构，构建非阻塞算法的 “技巧” 是确保数据结构总处于一致的状态（甚至包括在线程开始修改数据结构和它完成修改之间）.
还要确保其他线程不仅能够判断出第一个线程已经完成了更新还是处在更新的中途，还能够判断出如果第一个线程完成更新还需要什么操作。如果线程发现了处在更新中途的数据结构，它就可以 “帮助” 正在执行更新的线程完成更新，然后再进行自己的操作。当第一个线程回来试图完成自己的更新时，会发现不再需要了，返回即可，因为 CAS 会检测到帮助线程的干预（在这种情况下，是建设性的干预）。
这种 “帮助邻居” 的要求，对于让数据结构免受单个线程失败的影响，是必需的。如果线程发现数据结构正处在被其他线程更新的中途，然后就等候其他线程完成更新，那么如果其他线程在操作中途失败，这个线程就可能永远等候下去。即使不出现故障，这种方式也会提供糟糕的性能，因为新到达的线程必须放弃处理器，导致上下文切换，或者等到自己的时间片过期（而这更糟）。
下面
LinkedQueue
显示了Michael-Scott 非阻塞队列算法的插入操作，它是由
ConcurrentLinkedQueue
实现的：
|
public class LinkedQueue
private AtomicReference
= new AtomicReference
private AtomicReference
public boolean put(E item) {
Node
while (true) {
Node
Node
if (curTail == tail.get()) {
if (residue == null) /* A */ {
if (
curTail.next.compareAndSet(null, newNode)) /* C */ {
tail.compareAndSet(curTail, newNode) /* D */ ;
return true;
}
} else {
tail.compareAndSet(curTail, residue) /* B，把尾指针向前移动 */;
}
}
}
}
private static class Node
final E item;
final AtomicReference
Node(E item, Node
this.item = item;
this.next = new AtomicReference
}
}
}
|
像许多队列算法一样，空队列只包含一个假节点。头指针总是指向假节点；尾指针总指向最后一个节点或倒数第二个节点。
插入一个元素涉及两个指针更新，这两个更新都是通过 CAS 进行的：从队列当前的最后节点（步骤C）链接到新节点，并把尾指针移动到新的最后一个节点（步骤D）。
如果第一步失败，那么队列的状态不变，插入线程会继续重试，直到成功。
一旦操作成功，插入被当成生效，其他线程就可以看到修改。还需要把尾指针移动到新节点的位置上，但是这项工作可以看成是 “清理工作”，因为任何处在这种情况下的线程都可以判断出是否需要这种清理，也知道如何进行清理。
图 1. 正常状态：有两个元素，处在静止状态的队列
图 2.
中间状态：
在新元素插入之后，尾指针更新之前
图 3. 正常状态：在尾指针更新后，队列重新处在静止状态
队列总是处于两种状态之一：
正常状态（或称静止状态，图 1 和 图 3）或 中间状态（图 2）。
在插入操作之前和第二个 CAS（D）成功之后，队列处在静止状态；在第一个 CAS（C）成功之后，队列处在中间状态。
在静止状态时，尾指针指向的链接节点的 next 字段总为 null，而在中间状态时，这个字段为非 null。任何线程通过比较 tail.next 是否为 null，就可以判断出队列的状态，这是让线程可以帮助其他线程 “完成” 操作的关键。
插入操作在插入新元素（A）之前，先检查队列是否处在中间状态。如果是在中间状态，那么肯定有其他线程已经处在元素插入的中途，在步骤（C）和（D）之间。不必等候其他线程完成，当前线程就可以 “帮助” 它完成操作，把尾指针向前移动（B）。
如果有必要，它还会继续检查尾指针并向前移动指针，直到队列处于静止状态，这时它就可以开始自己的插入了。
第一个 CAS（C）可能因为两个线程竞争访问队列当前的最后一个元素而失败；在这种情况下，没有发生修改，失去 CAS 的线程会重新装入尾指针并再次尝试。
如果第二个 CAS（D）失败，插入线程不需要重试 —— 因为其他线程已经在步骤（B）中替它完成了这个操作！
非阻塞算法要比基于锁的算法复杂得多。
开发非阻塞算法是相当专业的训练，而且要证明算法的正确也极为困难。但是在 Java 版本之间并发性能上的众多改进来自对非阻塞算法的采用，所以尽量采用Java自带的非阻塞数据结构，而尽量不要试图自己实现。
————————— 基于 COW操作 来实现 —————————
Java中，List在遍历的时候，如果被修改了会抛出java.util.ConcurrentModificationException错误。所以衍生出一种要求, 读的时候可以改, 这样就不会造成读的效率太低。
Copy-On-Write简称COW，是一种用于程序设计中的优化策略。其基本思路是，从一开始大家都在共享同一个内容，当某个人想要修改这个内容的时候，才会真正把内容Copy出去形成一个新的内容然后再改，这是一种延时懒惰策略。
通俗的理解是当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。
这样做的好处是我们可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。
所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。
在Java中典型的实现是：CopyOnWriteArrayList。
|
/**
* Appends the specified element to the end of this list.
*
* @param e element to be appended to this list
* @return true (as specified by {@link Collection#add})
*/
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);
newElements[len] = e;
setArray(newElements);
return true;
} finally {
lock.unlock();
}
}
|
向CopyOnWriteArrayList中add方法的实现（向CopyOnWriteArrayList里添加元素），可以发现在添加的时候是需要加锁的，否则多线程写的时候会Copy出N个副本出来。 |
|
public E get(int index) {
return
get(getArray(), index);
}
|
读的时候不需要加锁，如果读的时候有多个线程正在向CopyOnWriteArrayList添加数据，读还是会读到旧的数据，因为写的时候不会锁住旧的CopyOnWriteArrayList |
CopyOnWrite并发容器用于读多写少的并发场景。比如白名单，黑名单，商品类目的访问和更新场景，假如我们有一个搜索网站，用户在这个网站的搜索框中，输入关键字搜索内容，但是某些关键字不允许被搜索。这些不能被搜索的关键字会被放在一个黑名单当中，黑名单每天晚上更新一次。当用户搜索时，会检查当前关键字在不在黑名单当中，如果在，则提示不能搜索。
内存占用问题。
因为CopyOnWrite的写时复制机制，所以在进行写操作的时候，内存里会同时驻扎两个对象的内存，旧的对象和新写入的对象（注意:在复制的时候只是复制容器里的引用，只是在写的时候会创建新对象添加到新容器里，而旧容器的对象还在使用，所以有两份对象内存）。如果这些对象占用的内存比较大，比如说200M左右，那么再写入100M数据进去，内存就会占用300M，那么这个时候很有可能造成频繁的Yong GC和Full GC。之前我们系统中使用了一个服务由于每晚使用CopyOnWrite机制更新大对象，造成了每晚15秒的Full GC，应用响应时间也随之变长。
针对内存占用问题，可以通过压缩容器中的元素的方法来减少大对象的内存消耗，比如，如果元素全是10进制的数字，可以考虑把它压缩成36进制或64进制。或者不使用CopyOnWrite容器，而使用其他的并发容器，如ConcurrentHashMap。
数据一致性问题。
CopyOnWrite容器只能保证数据的最终一致性，不能保证数据的实时一致性。所以如果你希望写入的的数据，马上能读到，请不要使用CopyOnWrite容器。
————————— 基于 分段锁 来实现 —————————
ConcurrentHashMap允许多个修改操作并发进行，其关键在于使用了锁分离技术。它使用了多个锁来控制对hash表的不同部分进行的修改。ConcurrentHashMap内部使用段(Segment)来表示这些不同的部分，每个段其实就是一个小的hash table，它们有自己的锁。只要多个修改操作发生在不同的段上，它们就可以并发进行。
有些方法需要跨段，比如size()和containsValue()，它们可能需要锁定整个表而而不仅仅是某个段，这需要按顺序锁定所有段，操作完毕后，又按顺序释放所有段的锁。
这里“按顺序”是很重要的，否则极有可能出现死锁，
在ConcurrentHashMap内部，段数组是final的，并且其成员变量实际上也是final的，但是，仅仅是将数组声明为final的并不保证数组成员也是final的，这需要实现上的保证。这可以确保不会出现死锁，因为获得锁的顺序是固定的。
|
public class ConcurrentHashMap
implements ConcurrentMap
final int segmentMask;
final int segmentShift;
final Segment
}
|
ConcurrentHashMap为了提高本身的并发能力，在内部采用了一个叫做Segment的结构，一个Segment其实就是一个类Hash Table的结构，Segment内部维护了一个链表数组，我们用下面这一幅图来看下ConcurrentHashMap的内部结构：
上面的结构我们可以了解到，
ConcurrentHashMap定位一个元素的过程需要进行两次Hash操作，第一次Hash定位到Segment，第二次Hash定位到元素所在的链表的头部，因此，这一种结构的带来的副作用是Hash的过程要比普通的HashMap要长，但是带来的好处是写操作的时候可以只对元素所在的Segment进行加锁即可，不会影响到其他的Segment，
这样，在最理想的情况下，ConcurrentHashMap可以
最高同时支持Segment数量大小的写操作
（刚好这些写操作都非常平均地分布在所有的Segment上），所以，通过这一种结构，ConcurrentHashMap的并发能力可以大大的提高。
ConcurrentHashMap也增加了对常用复合操作的支持，比如"若没有则添加"：putIfAbsent()，替换：replace()。这2个操作都是原子操作。
每个Segment相当于一个HashMap.
|
static final class Segment
private static final long serialVersionUID = 2249069246763182397L;
transient volatile int count; // * The number of elements in this segment's region.
transient int modCount;
transient int threshold; // * The table is rehashed when its size exceeds this threshold.
transient volatile HashEntry
final float loadFactor;
}
|
count用来统计该段数据的个数，它是volatile，它用来协调修改和读取操作，以保证读取操作能够读取到几乎最新的修改。协调方式是这样的，每次修改操作做了结构上的改变，如增加/删除节点(修改节点的值不算结构上的改变)，都要写count值，每次读取操作开始都要读取count的值。
这利用了Java 5中对volatile语义的增强，对同一个volatile变量的写和读存在happens-before关系(偏序关系)(参见单独的分析, 大致意思说, 任何写对读都是直接可见的)。
modCount统计段结构改变的次数，主要是为了检测对多个段进行遍历过程中某个段是否发生改变，在讲述跨段操作时会还会详述。
threashold用来表示需要进行rehash的界限值。
table数组存储段中节点，每个数组元素是个hash链，用HashEntry表示。table也是volatile，这使得能够读取到最新的table值而不需要同步。
loadFactor表示负载因子。
CurrentHashMap的执行细节涉及到很多复杂的过程，值得单独研究，所以本文不做重点阐述。
参考
http://ifeve.com/java-copy-on-write/
http://www.iteye.com/topic/344876
http://www.jasongj.com/java/concurrenthashmap/
https://www.ibm.com/developerworks/cn/java/j-jtp04186/
http://lazy2009.iteye.com/blog/1892559