ConcurrentHashMap
HashMap是线程不安全的，可以使用Collections.synchronizedMap(map)把一个不安全的map变成安全的，但是这里可以直接使用ConcurrentHashMap。
ConcurrentHashMap是线程安全的的Hash表。对于多线程的操作，介于HashMap和HashTable之间。内部采用“锁分段”机制替代HashTable的独占锁，进而提高性能。
一个ConcurrentHashMap由多个segment【默认16个】组成，每一个segment都包含了一个HashEntry数组的HashTable， 每一个segment包含了对自己的HashTable的操作，比如get，put，replace等操作，这些操作发生的时候，对自己的HashTable进行锁定。由于每一个segment写操作只锁定自己的HashTable，所以可能存在多个线程同时写的情况，性能无疑好于只有一个HashTable锁定的情况。
示例：
ConcurrentHashMap和HashMap在迭代过程中添加键值对的比较。
ConcurrentHashMap代码：
import java.util.Iterator;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap; public class ConcurrentHashMapDemo {
public static void main(String[] args) {
ConcurrentMap<String, String> cmap = new ConcurrentHashMap<>();
cmap.put("1", "111");
cmap.put("2", "222");
cmap.put("3", "333");
cmap.put("4", "444");
System.out.println("原Map:" + cmap);
Iterator<String> iterator = cmap.keySet().iterator();
while (iterator.hasNext()) {
String key = iterator.next();
if (key.equals("2")) {
cmap.put("new" + key, "new222");
}
}
System.out.println("修改后:" + cmap);
}
}
结果：
HashMap代码：
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map; public class HashMapDemo {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.put("1", "111");
map.put("2", "222");
map.put("3", "333");
map.put("4", "444");
System.out.println("原Map:" + map);
Iterator<String> it = map.keySet().iterator();
while (it.hasNext()) {
String key = it.next();
if (key.equals("2")) {
map.put("new" + key, "new222");
}
}
System.out.println("修改后:" + map);
}
}
结果：
查看输出，很明显ConcurrentHashMap可以支持向map中添加新元素，而HashMap则抛出了ConcurrentModificationException。查看异常堆栈记录，可以发现是下面这条语句抛出异常：
String key = it.next();
这就意味着新的元素在HashMap中已经插入了，但是在迭代器执行时出现错误。事实上，集合对象的迭代器提供快速失败（Fail-Fast）的机制，即修改集合对象结构或者元素数量都会使迭代器触发这个异常。
使用要点简单总结：
1、 get方法不涉及到锁，也就是说获得对象时没有使用锁；
2、put、remove方法要使用锁，但并不一定有锁争用，原因在于ConcurrentHashMap将缓存的变量分到多个Segment，每个Segment上有一个锁，只要多个线程访问的不是一个Segment就没有锁争用，就没有堵塞，各线程用各自的锁，ConcurrentHashMap缺省情况下生成16个Segment，也就是允许16个线程并发的更新而尽量没有锁争用；
3、Iterator对象的使用，不一定是和其它更新线程同步，获得的对象可能是更新前的对象，ConcurrentHashMap允许一边更新、一边遍历，也就是说在Iterator对象遍历的时候，ConcurrentHashMap也可以进行remove,put操作，且遍历的数据会随着remove,put操作产出变化。
CopyOnWriteArrayList
ArrayList是线程不安全的，也可以使用 Collections.synchronizedList(list)变成线程安全的。这里也可以直接使用CopyOnWriteArrayList。
CopyOnWriteArrayList是线程安全的，它内部持有了ReenTrantLock对象，它使用了一种叫写时复制的方法，当有新元素添加到CopyOnWriteArrayList时，先从原有的数组中拷贝一份出来，然后在新的数组做写操作，写完之后，再将原来的数组引用指向到新数组。而读的时候不加锁不阻塞，即在原版上读，这样就实现了读写的分离。
示例：
这里主要测试它的线程安全性，不再与ArrayList作比较。
import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList; public class CopyOnWriteArrayListDemo {
static CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
static {
list.add("111");
list.add("222");
list.add("333");
list.add("444");
} public static void main(String[] args) {
Test test = new Test();
for (int i = 0; i < 5; i++) {
new Thread(test).start();
}
} static class Test implements Runnable { @Override
public void run() {
synchronized (this) { Iterator<String> it = list.iterator();
while (it.hasNext()) {
System.out.print(it.next() + " ");
}
System.out.println();
list.add("555");
}
}
}
}
结果：
CopyOnWriteArraySet
CopyOnWriteArraySet与CopyOnWriteArrayList的用法基本相同，唯一注意的就是CopyOnWriteArraySet是不允许重复（唯一）的。
示例：
我们修改一下CopyOnWriteArrayList的示例来看一下
import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArraySet; public class CopyOnWriteArraySetDemo {
static CopyOnWriteArraySet<String> set = new CopyOnWriteArraySet<>();
static {
set.add("111");
set.add("222");
set.add("222");
set.add("333");
} public static void main(String[] args) {
Test test = new Test();
for (int i = 0; i < 5; i++) {
new Thread(test).start();
}
} static class Test implements Runnable { @Override
public void run() {
synchronized (this) { Iterator<String> it = set.iterator();
while (it.hasNext()) {
System.out.print(it.next() + " ");
}
System.out.println();
set.add("444");
}
}
}
}
结果：
