目录
一.同步类容器
二.并发类容器
2.1 ConcurrentMap
2.2 Copy-On-Write容器
同步类容器是线程安全的，但在某些场景下可能需要加锁来保护复合操作，例如：迭代（反复访问元素，元素的遍历）、跳转（根据指定的顺序找到当前元素的下一个元素）以及条件运算。这些复合操作在多线程并发的修改容器时，可能会表现出意外的行为，最经典的是ConcurrentModificationException，原因是当容器迭代的过程中，被并发的修改了内容，这是由于早期迭代器设计的时候并没有考虑到并发修改的问题。看如下的代码，Vector虽然是线程安全的，但是在复合操作（迭代加修改元素）的时候，也是会抛出ConcurrentModificationException异常：
public class Tickets { public static void main(String[] args) { //初始化火车票池并添加火车票:避免线程同步可采用Vector替代ArrayList Hashtable替代HashMap final Vector<String> tickets = new Vector<String>(); for (int i = 1; i <= 1000; i++) { tickets.add("火车票" + i); } for (Iterator iterator = tickets.iterator(); iterator.hasNext(); ) { String string = (String) iterator.next(); System.out.println("当前元素：" + string); tickets.remove(20); } } }多线程非复合操作下，vector是线程安全的，如下实例代码：
public class Tickets { public static void main(String[] args) { //初始化火车票池并添加火车票:避免线程同步可采用Vector替代ArrayList HashTable替代HashMap final Vector<String> tickets = new Vector<String>(); for (int i = 1; i <= 100000; i++) { tickets.add("火车票" + i); } for(int i = 1; i <=10; i ++){ new Thread("线程"+i){ public void run(){ while(true){ if(tickets.isEmpty()) break; System.out.println(Thread.currentThread().getName() + "---" + tickets.remove(0)); } } }.start(); } } }各个线程不断的去移除元素，并未出现异常。
同步类容器：如古老的Vector、Hashtable。这些容器的同步功能其实都是有JDK的Collection.synchronized等工厂方法去创建实现的。其底层的机制无非就是用传统的synchronized关键字对每个公共的方法都进行同步，使得每次操作只能有一个线程去访问容器的状态。这很明显不满足我们今天互联网时代高并发的需求，无法保证足够的性能。
假如我们直接使用ArrayList，做并发的删除操作，会出现并发问题，代码如下：
public class Tickets { public static void main(String[] args) { //初始化火车票池并添加火车票:避免线程同步可采用Vector替代ArrayList HashTable替代HashMap List<String> tickets = new ArrayList<String>(); for (int i = 1; i <= 100000; i++) { tickets.add("火车票" + i); } for (int i = 1; i <= 10; i++) { new Thread("线程" + i) { public void run() { while (true) { if (tickets.isEmpty()) break; System.out.println(Thread.currentThread().getName() + "---" + tickets.remove(0)); } } }.start(); } } }输出的结果中，会出现打印为空的元素，从而证明ArrayList不是线程安全的。此时我们可以使用Collections.synchronizedList方法，将tickets设置为线程安全的。
public class Tickets { public static void main(String[] args) { //初始化火车票池并添加火车票:避免线程同步可采用Vector替代ArrayList HashTable替代HashMap List<String> tickets = Collections.synchronizedList(new ArrayList<>()); for (int i = 1; i <= 100000; i++) { tickets.add("火车票" + i); } for (int i = 1; i <= 10; i++) { new Thread("线程" + i) { public void run() { while (true) { if (tickets.isEmpty()) break; System.out.println(Thread.currentThread().getName() + "---" + tickets.remove(0)); } } }.start(); } } }jdk5.0以后提供了多种并发类容器来替代同步类容器从而改善性能，并发类容器时专门针对并发设计的：使用ConcurrentHashMap来代替基于散列的Hashtable，并添加了一些常见符合操作的支持；使用CopyOnWriteArrayList代替Vector，并发的CopyOnWriteArraySet，以及并发的Queue：ConcurrentLinkedQueue和LinkedBlockingQueue，前者是高性能的队列，后者是以阻塞形式的队列。具体形式的Queue还有很多如：ArrayBlockingQueue、PriorityBlockingQueue、SynchronousQueue等。
ConcurrentMap接口有两个重要的实现：ConcurrentHashMap和ConcurrentSkipListMap（支持并发排序的功能，弥补ConcurrentHashMap的不足）。ConcurrentHashMap内部使用段（Segment）来表示这些不同的部分，每个段其实就是一个小的Hashtable，他们有自己的锁，只要多个修改操作发生在不同的段上，它们就可以并发执行。ConcurrentHashMap把一个整体分成了16个段，也就是最高支持16个线程的并发修改操作，这也是在多线程场景下减小锁的粒度从而降低锁竞争的一种方案，同时代码中大多数的共享变量使用volatile关键字声明，目的是第一时间获取修改的内容，性能非常好。
public class UseConcurrentMap { public static void main(String[] args) { ConcurrentHashMap<String, Object> chm = new ConcurrentHashMap<String, Object>(); chm.put("k1", "v1"); chm.put("k2", "v2"); chm.put("k3", "v3"); chm.putIfAbsent("k3", "vvvv"); for (Map.Entry<String, Object> me : chm.entrySet()) { System.out.println("key:" + me.getKey() + ",value:" + me.getValue()); } } }输出结果为：
key:k1,value:v1 key:k2,value:v2 key:k3,value:v3在上面的结果中，k3的输出值是v3，并不是vvvv。putIfAbsent方法表示，如果当前key已经有值了，则不再添加当前元素了，否则会添加。
ConcurrentHashMap
ConcurrentHashMap是线程安全且高效的HashMap。为什么要使用ConcurrentHashMap？因为在并发编程中使用HashMap可能导致程序死循环，而使用线程安全的HashTable效率又非常低下。
线程不安全的HashMap在多线程环境下，使用HashMap进行put操作会引起死循环，导致CPU的利用率接近100%，所以并发环境下不能使用HashMap。一般来说Hash表容器中当有容器要插入时，都会检查容量有没有超过设定的thredhold，如果超过，需要增大HASH表的尺寸，此时整个Hash表中的元素都要重新计算一遍并拷贝到新表中，这叫rehash。当多线程程序并发执行put操作引发Hash表扩容，进行rehash时，会导致HashMap的Entry链表形成环形数据结构，一旦形成环形数据结构，Entry的next节点永远不为空就会产生死循环获取Entry的情况。
效率低下的HashTableHashTable容器使用synchronized来保证线程安全，但是线程竞争激烈的情况下HashTable的效率非常低下。
ConcurrentHashMap的锁分段技术可以提升并发访问率Hashtable容器在竞争激烈的情况下表现出效率低下的主要原因是所有访问Hashtable的线程都必须竞争一把锁，而ConcurrentHashMap使用锁分段技术将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程所访问。
ConcurrentHashMap的结构
ConcurrentHashMap是由Segment数组结构和HashEntry数组结构组成。Segment是一种可重入锁，在ConcurrentHashMap里面扮演锁的角色；HashEntry则用于存储键值对数据。一个ConcurrentHashMap里包含一个Segment数组，一个Segment里包含一个HashEntry数组，每个HashEntry是一个链表结构的元素，每个Segment守护着一个HashEntry数组里的元素，当对HashEntry数组的数据进行修改时，必须首先获得与它对应的Segment锁。ConcurrentHashMap的类图：
copy-on-write简称COW，是一种用于程序设计中的优化策略。JDK中的COW容器有两种，CopyOnWriteArrayList和CopyOnWriteArraySet，COW容器非常的有用，可以在非常多的并发场景中使用到。
什么是CopyOnWrite容器？
CopyOnWrite容器即写时复制的容器，通俗的理解是当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后往新的容器里添加元素。元素添加完成之后，再将原容器的引用指向新的容器。这样做的好处是我们可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何的元素，所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器，非常适合读多写少的情况。CopyOnWriteArrayList读写分离的核心代码如下：
/** * Appends the specified element to the end of this list. * * @param e element to be appended to this list * @return {@code 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(); } }CopyOnWriteArraySet添加元素的实现代码如下：
/** * A version of addIfAbsent using the strong hint that given * recent snapshot does not contain e. */ private boolean addIfAbsent(E e, Object[] snapshot) { final ReentrantLock lock = this.lock; lock.lock(); try { Object[] current = getArray(); int len = current.length; if (snapshot != current) { // Optimize for lost race to another addXXX operation int common = Math.min(snapshot.length, len); for (int i = 0; i < common; i++) if (current[i] != snapshot[i] && eq(e, current[i])) return false; if (indexOf(e, current, common, len) >= 0) return false; } Object[] newElements = Arrays.copyOf(current, len + 1); newElements[len] = e; setArray(newElements); return true; } finally { lock.unlock(); } }
