目录
一.同步类容器
同步类容器是线程安全的，但在某些场景下可能需要加锁来保护复合操作，例如：迭代（反复访问元素，元素的遍历）、跳转（根据指定的顺序找到当前元素的下一个元素）以及条件运算。这些复合操作在多线程并发的修改容器时，可能会表现出意外的行为，最经典的是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等。
2.1 ConcurrentMap
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已经有值了，则不再添加当前元素了，否则会添加。
2.2 Copy-On-Write容器
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();
}
}