ConcurrentHashMap
HashMap是线程非安全的，在多线程环境下，采用的是Fail-Fast快速失败机制，即当A线程在访问容器的时候，如果此时B线程修改了HashMap的结构，那么就会抛出并发修改异常。且当A线程添加一个Entry的时候，它会首先获得头节点，如果此时B线程也要添加一个Entry的时候，它会获得同样的头节点，那么当A线程添加完newEntry之后，B线程实际上会将A的覆盖掉。
HashTable是一个线程安全的类，它使用synchronized来锁住整张Hash表来实现线程安全，即每次锁住整张表让线程独占。
Collections.synchronizedMap()是对方法加锁
public V get(Object key) {
synchronized (mutex) {return m.get(key);}
}能保证线程安全性，却影响并发条件下的性能，因为必须当A线程释放锁之后，B线程才能够获得锁并对map进行操作。
那么要如何保证在多线程环境下的线程安全性并保证性能呢？使用ConcurrentHashMap
ConcurrentHashMap采用的是分段锁技术，它的底层是一个Segment[]的数组（数组默认大小为16，即并发数为16），每个segment称为一个段，在每一段上又是一个类似于HashMap的数据结构，每个segment上都有一个锁。
ConcurrentHashMap允许多个修改操作并发执行，只要多个修改操作发生在不同的段上。有些方法需要跨段，比如size()和containsValue()，它们可能需要锁定整个表而而不仅仅是某个段，这需要按顺序锁定所有段，操作完毕后，又按顺序释放所有段的锁。
ConcurrentHashMap给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问，能够实现真正的并发访问。如下图是ConcurrentHashMap的内部结构图：
每个Segment都继承了ReentrantLock
static class Segment<K,V> extends ReentrantLock
如何在ConcurrentHashMap中put一个Entry呢？
public V put(K key, V value) {
Segment<K,V> s;
if (value == null) //判断value是否为null,如果为null直接抛出空指针异常
thrownew NullPointerException();
int hash = hash(key); //第一次计算hash值
int j = (hash >>> segmentShift) & segmentMask; //第二次计算hash值，这个值确定Segment的索引
if ((s = (Segment<K,V>)UNSAFE.getObject //获得Segment对象
(segments, (j << SSHIFT) + SBASE)) == null)
s = ensureSegment(j); //采用的是延迟初始化机制return s.put(key, hash, value, false); //真正的put，put操作是需要加锁的
}final V put(K key, int hash, V value, boolean onlyIfAbsent) {
HashEntry<K,V> node = tryLock() ? null :
scanAndLockForPut(key, hash, value);
V oldValue;
try {
HashEntry<K,V>[] tab = table;
int index = (tab.length - 1) & hash; //第三次hash操作，获得table中的具体index
HashEntry<K,V> first = entryAt(tab, index);
for (HashEntry<K,V> e = first;;) {
if (e != null) {
K k;
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) {
oldValue = e.value;
if (!onlyIfAbsent) {
e.value = value;
++modCount;
}
break;
}
e = e.next;
}
else {
if (node != null)
node.setNext(first);
else
node = new HashEntry<K,V>(hash, key, value, first);
int c = count + 1;
if (c > threshold && tab.length < MAXIMUM_CAPACITY)
rehash(node);
else
setEntryAt(tab, index, node);
++modCount;
count = c;
oldValue = null;
break;
}
}
} finally {
unlock();
}
return oldValue;
}如何从ConcurrentHashMap中根据key获取value呢？
public V get(Object key) {
Segment<K,V> s; // manually integrate access methods to reduce overhead
HashEntry<K,V>[] tab;
int h = hash(key);
long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
(tab = s.table) != null) {
for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
(tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
e != null; e = e.next) {
K k;
if ((k = e.key) == key || (e.hash == h && key.equals(k)))
return e.value;
}
}
return null;
}值得注意的是，get操作是不需要加锁的，而是通过Unsafe对象的getObjectVolatile()方法提供的原子读语义，来获得Segment以及对应的链表，然后对链表遍历判断是否存在key相同的节点以及获得该节点的value。但由于遍历过程中其他线程可能对链表结构做了调整，因此get和containsKey返回的可能是过时的数据，这一点是ConcurrentHashMap在弱一致性上的体现。
size操作需要遍历所有的Segment才能算出整个Map的大小。假设我们当前遍历的Segment为S1，那么在遍历S1过程中其他的Segment比如S2可能会被修改，于是这一次运算出来的size值可能并不是Map当前的真正大小。所以一个比较简单的办法就是计算Map大小的时候所有的Segment都Lock住，不能更新(包含put，remove等等)数据，计算完之后再Unlock。这是普通人能够想到的方案，但是牛逼的作者还有一个更好的Idea：先给3次机会，不lock所有的Segment，遍历所有Segment，累加各个Segment的大小得到整个Map的大小，如果某相邻的两次计算获取的所有Segment的更新的次数（每个Segment都有一个modCount变量，这个变量在Segment中的Entry被修改时会加一，通过这个值可以得到每个Segment的更新操作的次数）是一样的，说明计算过程中没有更新操作，则直接返回这个值。如果这三次不加锁的计算过程中Map的更新次数有变化，则之后的计算先对所有的Segment加锁，再遍历所有Segment计算Map大小，最后再解锁所有Segment。源代码如下：
public int size() {
// Try a few times to get accurate count. On failure due to
// continuous async changes in table, resort to locking.
final Segment<K,V>[] segments = this.segments;
int size;
boolean overflow;
long sum; // 总的修改次数
long last = 0L; // 前一次的修改次数
int retries = -1;
try {
for (;;) {
if (retries++ == RETRIES_BEFORE_LOCK) {
for (int j = 0; j < segments.length; ++j)
ensureSegment(j).lock(); // 如果三次还不行，则需要强制给所有segment加锁
}
sum = 0L;
size = 0;
overflow = false;
for (int j = 0; j < segments.length; ++j) {
Segment<K,V> seg = segmentAt(segments, j);
if (seg != null) {
sum += seg.modCount;
int c = seg.count;
if (c < 0 || (size += c) < 0)
overflow = true;
}
}
if (sum == last)
break;
last = sum;
}
} finally {
if (retries > RETRIES_BEFORE_LOCK) {
for (int j = 0; j < segments.length; ++j)
segmentAt(segments, j).unlock();
}
}
return overflow ? Integer.MAX_VALUE : size;
}containsValue操作采用了和size操作一样的想法:
public boolean containsValue(Object value) {
// Same idea as size()
if (value == null)
throw new NullPointerException();
final Segment<K,V>[] segments = this.segments;
boolean found = false;
long last = 0;
int retries = -1;
try {
outer: for (;;) {
if (retries++ == RETRIES_BEFORE_LOCK) {
for (int j = 0; j < segments.length; ++j)
ensureSegment(j).lock(); // force creation
}
long hashSum = 0L;
int sum = 0;
for (int j = 0; j < segments.length; ++j) {
HashEntry<K,V>[] tab;
Segment<K,V> seg = segmentAt(segments, j);
if (seg != null && (tab = seg.table) != null) {
for (int i = 0 ; i < tab.length; i++) {
HashEntry<K,V> e;
for (e = entryAt(tab, i); e != null; e = e.next) {
V v = e.value;
if (v != null && value.equals(v)) {
found = true;
break outer;
}
}
}
sum += seg.modCount;
}
}
if (retries > 0 && sum == last)
break;
last = sum;
}
} finally {
if (retries > RETRIES_BEFORE_LOCK) {
for (int j = 0; j < segments.length; ++j)
segmentAt(segments, j).unlock();
}
}
return found;
}ArrayList是非线程安全的，Vector是线程安全的，因为它的方法都加了synchronized关键字，但是Vector效率很低。
public synchronized int size() {
return elementCount;
}CopyOnWriteArrayList：写时复制ArrayList，在读的时候不加锁，在写的时候，首先会对原数组a进行拷贝a1，修改操作都是在a1上进行的，当修改完成之后，再将a指针指向拷贝的数组。这样做的好处是我们可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。
向List中添加一个元素,在添加的时候是需要加锁的，否则多线程写的时候会Copy出N个副本出来。
/** * Appends the specified element to the end of this list. */ 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添加数据，读还是会读到旧的数据，因为写的时候不会锁住旧的List。
public E get(int index) { return get(getArray(), index);}CopyOnWriteArrayList用于读多写少的并发场景，它只能保证数据的最终一致性，不能保证数据的实时一致性。所以如果你希望写入的的数据，马上能读到，请不要使用CopyOnWrite容器。