推荐《java 并发编程实战》这本书，中文的翻译有些差（哈哈，并发确实难，不好翻译），适合有并发经验的人来读。
这篇短文，整理了容器的知识点，对容器的使用场景，容器的原理等有个整体的认知！
1. 层次构造
看看下面的Collection层次构造图：
（这张图为突出某些重点，对层次上的东西进行了取舍，此外类继承的多个接口，也没有表示出来）
FIFO：first-in-first-out
bounded：有界队列
doubly-linked：双向链表
natural ordering：自然顺序
上图中，我们常用的集合基本都罗列了。一些需要注意到的东西也在上面列举了，希望大家好好看看。在类或接口的右上方，有些注释，标明了它的一次特点或是原理。
接下来看看Map的部分：
我们再看一下面这张图，阐述了容器实现的方式：
2. 迭代器
ArrayList、LinkedList等容器的实现都不是同步的。在多线程的情况下，必须进行额外的同步操作。一种方式就是，加上同步器，同步器的锁就是list。另外一种方式，在容器创建的时候，用Collections中的方法对容器进行包装，示例如下：
List list = Collections.synchronizedList(new ArrayList()); // 包装之后，就是线程安全的。
...
synchronized (list) { // 不加锁的话，迭代器会出现ConcurrentModificationException
// 这里呢，还有一种可替代方案：克隆容器，然后在副本上进行迭代
Iterator i = list.iterator(); // Must be in synchronized block
while (i.hasNext())
foo(i.next());
}
Map m = Collections.synchronizedMap(new HashMap());
...
Set s = m.keySet(); // Needn't be in synchronized block
...
synchronized (m) { // Synchronizing on m, not s!
Iterator i = s.iterator(); // Must be in synchronized block
while (i.hasNext())
foo(i.next());
}
（Collections中还有其他实用的方法，请查看java api）
3. 并发容器
ConcurrentHashMap：
使用分段锁的机制，允许任意数量的读取线程并发访问Map，并且一定数量的写入线程可以并发地修改Map。它带来的结果是，在并发访问环境下将实现更好的吞吐量，而在单线程环境中只损失非常小的性能。ConcurrentHashMap和其他并发容器不会抛出ConcurrentModificationException，因此不需要再迭代过程中对容器加锁。ConcurrentHashMap返回的迭代器具有弱一致性，而并非“及时失败”。弱一致性的迭代器可以容忍并发的修改。
（弱一致性该如何理解呢？数据更新后，如果能容忍后续的访问只能访问到部分或者全部访问不到，则是弱一致性。举例说明，可能你期望往ConcurrentHashMap中加入一个元素后，立马能对get可见，但ConcurrentHashMap并不能如你所愿。换句话说，put操作将一个元素加入后，get可能在某段时间内还看不到这个元素）
对于一些需要在整个Map上进行计算的方法，如size和isEmpty，这些方法的语义被略微减弱了以反映容器的并发特性。
额外的原子Map操作：
一些常见的复合操作，例如“若没有则添加”、“若相等则移除”、“若相等则替换”等，这些操作都是原子操作，不需要加锁。
computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)
computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
putIfAbsent(K key, V value)
remove(Object key, Object value)
replace(K key, V value)
CopyOnWriteArrayList：
用于替代同步List，在某些情况下提供了更好的并发性能，并且在迭代期间不需要对容器进行加锁或是复制。Copy-On-Write的安全性在于每次修改时，都会创建并重新发布一个新的容器的副本，从而实现可变性。但是这需要一定的开销，特别是当容器的规模较大时。仅当迭代操作远多于修改操作时，才应该使用“写入时复制”容器。
4. 链表
分为单向链表（singly-linked list）和双向链表（doubly-linked list）。
首先说一下链表（linked list）和数组（Array）的区别：
①Array是静态分配内存，不能动态扩展。在插入和删除方面，开销很大，但随机访问性强，查找速度快；linked list是动态分配内存，nodes数量可以按需求增加或减少，因此，处理未知数量的对象时，应该使用linked list。虽然，它插入删除速度快，但不能随机查找。
②链表结构区别
singly-linked list:
doubly-linked list:
链表跟内存相比会占用更多内存，我们需花费额外的4bytes（32bitCPU中）内存来存储每个reference。
③doubly-linked list在查找和删除时利用了二分法的思想去实现，效率大大提高，但singly-linked list的应用更广泛。原因在于存储效率方面。
每个doubly-linked list的node结构比singly-linked list的多了一个指针，占用更多空间，这时设计者会以时间来换取空间，达到工程总体的平衡。
参考资料：https://www.cs.cmu.edu/~adamchik/15-121/lectures/Linked%20Lists/linked%20lists.html
5. SynchronousQueue
它有两个操作，put()和take()，这两个操作都是阻塞的。比如：当我们执行put()和，会一直阻塞到其他线程执行take()为止。队列的内部没有任何的存储容量（一个都没有），所以它不能插入数据，也不能移除数据，还不能进行迭代。newCachedThreadPool的实现，队列的部分就是使用了SysnchronousQueue。（newCachedThreadPool的特点，接收到一个新的任务就直接开启一个新的线程来执行）
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE, // 0代表corePoolSize Integer.MAX_VALUE代表maximumPoolSize
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
我们先一个用公共变量来处理传递：
public class Demo002 {
public static void main(String args[]) throws InterruptedException {
ExecutorService executor = Executors.newFixedThreadPool(2);
AtomicInteger sharedState = new AtomicInteger();
CountDownLatch countDownLatch = new CountDownLatch(1);
Runnable producer = () -> {
Integer producedElement = ThreadLocalRandom
.current()
.nextInt();
sharedState.set(producedElement);
countDownLatch.countDown();
};
Runnable consumer = () -> {
try {
countDownLatch.await();
Integer consumedElement = sharedState.get();
} catch (InterruptedException ex) {
ex.printStackTrace();
}
};
executor.execute(producer);
executor.execute(consumer);
executor.awaitTermination(500, TimeUnit.MILLISECONDS);
executor.shutdown();
System.out.println(countDownLatch.getCount());
}
}
再用SysnchronousQueue处理传递：
public class Demo003 {
public static void main(String args[]) throws InterruptedException {
ExecutorService executor = Executors.newFixedThreadPool(2);
SynchronousQueue<Integer> queue = new SynchronousQueue<>();
Runnable producer = () -> {
Integer producedElement = ThreadLocalRandom
.current()
.nextInt();
try {
queue.put(producedElement);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
};
Runnable consumer = () -> {
try {
Integer consumedElement = queue.take();
} catch (InterruptedException ex) {
ex.printStackTrace();
}
};
executor.execute(producer);
executor.execute(consumer);
executor.awaitTermination(500, TimeUnit.MILLISECONDS);
executor.shutdown();
System.out.println(queue.size());
}
}
至此，我们看到了它的构造，用例子阐述了它的使用方法，SynchronousQueue服务于一个交换点，这个交换点用于生产者和消费者的协作。