一、Vector
Vector集合是对ArrayList集合线程安全的实现，它们两者在方法的实现上没有什么太大的区别，最大的区别就是，Vector在方法前面加上了synchronized 关键字，用于保证线程安全。
具体可以查看：这里
Vector存在的问题：
-
1、它的 add() 和 get() 方法都能够获取当前 Vector 对象的对象锁，但是有可能会发生读读互斥。
-
2、当 threadA 在1 下标处添加一个元素，threadB在2下标处修改一个元素时，同样有可能会发生互斥现象。
Vector v = new Vector(); thread1: v.add(100, 1); thread2: v.set(50, 2);
二、HashTable
HashTable集合是对HashMap集合线程安全的实现，它们两者在方法的实现上没有什么太大的区别，最大的区别就是，HashTable在方法前面加上了synchronized关键字，用于保证线程安全。
具体内容 查看 这里
HashTable存在的问题：
- 由于 HashTable 和 Vector 在本质上都是在方法前面加上 synchronized 关键字，因此，它们两个存在的问题也是同样相同的，均有可能发生互斥现象。
由此可知，HashTable所存在的锁的粒度也是非常大的，也同样会导致在多线程情况下，程序执行的效率有可能会十分低下。
为了解决Vector集合和HashTable集合效率低下的问题，我们在选取线程安全的集合时一般会选择 CopyOnWriteArrayList集合和ConcurrentHashMap集合，它的锁的粒度相较于Vector和HashTable更小，因此能够高效率的解决Vector和HashTable所存在的问题。
三、ConcurrentHashMap
ConcurrentHashMap是Java中的一个线程安全且高效的HashMap实现。平时涉及高并发如果要用map结构，那第一时间想到的就是它。
我们从以下几个方面来了解一下ConcurrentHashMap：
- 1、ConcurrentHashMap在JDK8里的结构。
- 2、ConcurrentHashMap的put方法、szie方法等。
- 3、ConcurrentHashMap的扩容。
- 4、HashMap、Hashtable、ConccurentHashMap三者的区别。
- 5、ConcurrentHashMap在JDK7和JDK8的区别。
CurrentHashMap与HashMap的底层结构一致，都是基于数组+链表+红黑树进行实现。
那么它是如何保证线程安全的呢？
答案：JDK1.8 抛弃了原有 JDK1.7 的 Segment 分段锁，而采用了 CAS + synchronized 来保证并发安全性。
现在我们来解决另一个问题，为什么HashMap不是线程安全的？
-
表现1： 多个线程同时操作一个hashmap就可能出现不安全的情况：
比如A B两个线程(A线程获数据 B线程存数据) 同时操作myHashMap B线程执行存放数据 modelHashMap.put("1","2"); A线程执行get获取数据 modelHashMap.get("1")A线程获取的值本来应该是2，但是如果A线程在刚到达获取的动作还没执行的时候，线程执行的机会又跳到线程B，此时线程B又对modelHashMap赋值 如
modelHashMap.put("1","3")，然后线程虚拟机又执行线程A，A取到的值为3，这样map中第一个存放的值 就会丢失。 -
表现2： 一般我们声明HashMap时，使用的都是默认的构造方法：HashMap<K,V>，看了代码你会发现，它还有其它的构造方法：
HashMap(int initialCapacity, float loadFactor)，其中参数initialCapacity为初始容量，loadFactor为加载因子，而之前我们看到的threshold = (int)(capacity * loadFactor);
如果在默认情况下，一个HashMap的容量为16，加载因子为0.75，那么阀值就是12，所以在往HashMap中put的值到达12时，它将自动扩容两倍，
如果两个线程同时遇到HashMap的大小达到12的倍数时，就很有可能会出现在将oldTable转移到newTable的过程中遇到问题，从而导致最终的HashMap的值存储异常。
关键属性与类
在了解 ConcurrentHashMap 的具体方法实现前，我们需要系统的来看一下几个关键的地方。
CAS(V,O,N)核心思想
- 若当前变量实际值 V 与期望的旧值 O 相同，则表明该变量没被其他线程进行修改，因此可以安全的将新值 N 赋值给变量；
- 若当前变量实际值 V 与期望的旧值 O 不相同，则表明该变量已经被其他线程做了处理，此时将新值 N 赋给变量操作就是不安全的，再进行重试。
- 而在大量的同步组件和并发容器的实现中使用 CAS 是通过
sun.misc.Unsafe类实现的，该类提供了一些可以直接操控内存和线程的底层操作，可以理解为 java 中的“指针”。
ConcurrentHashMap 的关键属性
-
table：装载 Node 的数组，作为 ConcurrentHashMap 的数据容器，采用懒加载的方式，直到第一次插入数据的时候才会进行初始化操作，数组的大小总是为 2 的幂次方。
/** * The array of bins. Lazily initialized upon first insertion. * Size is always a power of two. Accessed directly by iterators. */ transient volatile Node<K,V>[] table; -
nextTable : 扩容时新生成的数组，大小为原数组的2倍。平时为 null ，只有在扩容的时候才为非 null。
/** * The next table to use; non-null only while resizing. */ private transient volatile Node<K,V>[] nextTable; -
sizeCtl：该属性用来控制 table 数组的大小，根据是否初始化和是否正在扩容有几种情况：
- 当值为负数时：如果为 -1 表示正在初始化 ，如果为 -N 则表示当前正有 N-1 个线程进行扩容操作。
- 当值为正数时：如果当前数组为 null 的话表示 table 在初始化过程中，sizeCtl 表示为需要新建数组的长度。
- 若已经初始化了，表示当前数据容器（table 数组）可用容量也可以理解成临界值（插入节点数超过了该临界值就需要扩容），具体指为数组的长度n 乘以 加载因子loadFactor；
- 默认值为0，当table被初始化后，sizeCtl的值为下一次要扩容时元素个数。
-
sun.misc.Unsafe U ：在
ConcurrentHashMapde的实现中可以看到大量的U.compareAndSwapXXXX的方法去修改ConcurrentHashMap的一些属性。这些方法实际上是利用了 CAS 算法保证了线程安全性，这是一种乐观策略，假设每一次操作都不会产生冲突，当且仅当冲突发生的时候再去尝试。而 CAS 操作依赖于现代处理器指令集，通过底层CMPXCHG指令实现。static { try { U = sun.misc.Unsafe.getUnsafe(); ....... } catch (Exception e) { throw new Error(e); } }
ConcurrentHashMap 的关键内部类
-
Node： Node 类实现了 Map.Entry 接口，主要存放 key-value 对，并且具有 next 域
static class Node<K,V> implements Map.Entry<K,V> { final int hash; final K key; volatile V val; volatile Node<K,V> next; ...... }另外可以看出很多属性都是用 volatile 进行修饰的，也就是为了保证内存可见性。
-
TreeNode 树节点，继承于承载数据的 Node 类。而红黑树的操作是针对 TreeBin 类的，从该类的注释也可以看出，也就是 TreeBin 会将 TreeNode 进行再一次封装
** * Nodes for use in TreeBins */ static final class TreeNode<K,V> extends Node<K,V> { TreeNode<K,V> parent; // red-black tree links TreeNode<K,V> left; TreeNode<K,V> right; TreeNode<K,V> prev; // needed to unlink next upon deletion boolean red; ...... } -
ForwardingNode 在扩容时才会出现的特殊节点，其 key,value,hash 全部为 null。并拥有 nextTable 指针引用新的 table 数组。
static final class ForwardingNode<K,V> extends Node<K,V> { final Node<K,V>[] nextTable; ForwardingNode(Node<K,V>[] tab) { super(MOVED, null, null, null); this.nextTable = tab; } ..... }
CAS 关键操作
在上面我们提及到在 ConcurrentHashMap 中会大量使用 CAS 修改它的属性和一些操作。因此，在理解 ConcurrentHashMap 的方法前我们需要了解下面几个常用的利用 CAS 算法来保障线程安全的操作。
-
tabAt: 该方法用来获取 table 数组中索引为 i 的 Node 元素。
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) { return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE); } -
casTabAt: 利用 CAS 操作 table 数组中索引为 i 的元素
static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i, Node<K,V> c, Node<K,V> v) { return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v); } -
setTabAt 该方法用来设置 table 数组中索引为 i 的元素
static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) { U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v); }
ConcurrentHashMap的常用方法剖析
实例的构造器方法
// 1. 构造一个空的map，即table数组还未初始化，初始化放在第一次插入数据时，默认大小为16
ConcurrentHashMap()
// 2. 给定map的大小
ConcurrentHashMap(int initialCapacity)
// 3. 给定一个map
ConcurrentHashMap(Map<? extends K, ? extends V> m)
// 4. 给定map的大小以及加载因子
ConcurrentHashMap(int initialCapacity, float loadFactor)
// 5. 给定map大小，加载因子以及并发度（预计同时操作数据的线程）
ConcurrentHashMap(int initialCapacity,float loadFactor, int concurrencyLevel)
-
ConcurrentHashMap 一共给我们提供了 5 中构造器方法，具体使用请看注释，我们来看看第 2 种构造器，传入指定大小时的情况，该构造器源码为：
public ConcurrentHashMap(int initialCapacity) { //1. 小于0直接抛异常 if (initialCapacity < 0) throw new IllegalArgumentException(); //2. 判断是否超过了允许的最大值，超过了话则取最大值，否则再对该值进一步处理 int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY : tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1)); //3. 赋值给sizeCtl this.sizeCtl = cap; }如果小于 0 就直接抛出异常，如果指定值大于了所允许的最大值的话就取最大值，否则，在对指定值做进一步处理。最后将 cap 赋值给 sizeCtl,关于 sizeCtl 的说明请看上面的说明，当调用构造器方法之后，sizeCtl 的大小应该就代表了 ConcurrentHashMap 的大小，即 table 数组长度。 t
-
ableSizeFor 做了哪些事情了？源码为：
/** * Returns a power of two table size for the given desired capacity. * See Hackers Delight, sec 3.2 */ private static final int tableSizeFor(int c) { int n = c - 1; n |= n >>> 1; n |= n >>> 2; n |= n >>> 4; n |= n >>> 8; n |= n >>> 16; return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1; } -
通过注释就很清楚了，该方法会将调用构造器方法时指定的大小转换成一个 2 的幂次方数，也就是说 ConcurrentHashMap 的大小一定是 2 的幂次方，比如，当指定大小为 18 时，为了满足 2 的幂次方特性，实际上 concurrentHashMapd 的大小为 2 的 5 次方（32）。
-
2次幂的原因是因为计算索引是使用的是二进制的且运算，只有二进制的情况下才满足 索引不超过最大和满足等式 (n - 1) & hash = hash % n。还有一个原因就是 "&"的效率要比 “%” 快
-
另外，需要注意的是，调用构造器方法的时候并未构造出 table 数组（可以理解为 ConcurrentHashMap 的数据容器），只是算出 table 数组的长度，当第一次向 ConcurrentHashMap 插入数据的时候才真正的完成初始化创建 table 数组的工作。懒加载
初始化方法 initTable()
- CAS的思路 初始化table，当某个线程正在操作table时，sizeCtl会被置为 -1 ，此时其他线程会持续等待释放锁。
private final Node<K,V>[] initTable() { Node<K,V>[] tab; int sc; while ((tab = table) == null || tab.length == 0) { if ((sc = sizeCtl) < 0) // 1.sizeCtl < 0表示其他线程也正在初始化， //保证只有一个线程正在进行初始化操作，所以让出时间片 Thread.yield(); // lost initialization race; just spin //没有其他线程进行操作，那么就直接将sizeCtl置为-1。 else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) { try { if ((tab = table) == null || tab.length == 0) { // 2. 得出数组的大小 int n = (sc > 0) ? sc : DEFAULT_CAPACITY; @SuppressWarnings("unchecked") // 3. 这里才真正的初始化数组 Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n]; table = tab = nt; // 4. 计算数组中可用的大小：实际大小n*0.75（加载因子） sc = n - (n >>> 2); } } finally { sizeCtl = sc; } break; } } return tab; }
添加方法 put()
具体代码如下：
public V put(K key, V value) {
return putVal(key, value, false);
}
/** Implementation for put and putIfAbsent */
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
//1. 计算key的hash值
//spread(就是扰动函数)，让hashcode右移32位进行异或操作，来减少hash冲突
int hash = spread(key.hashCode());
int binCount = 0;
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
//2. 如果当前table还没有初始化先调用initTable方法将tab进行初始化
if (tab == null || (n = tab.length) == 0)
tab = initTable();
//3. tab中索引为i的位置的元素为null，则直接使用CAS将值插入即可
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
//4. 当前正在扩容
else if ((fh = f.hash) == MOVED)
//当前线程去辅助扩容。
tab = helpTransfer(tab, f);
else {
V oldVal = null;
synchronized (f) {
if (tabAt(tab, i) == f) {
//5. 当前为链表，在链表中插入新的键值对
if (fh >= 0) {
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
K ek;
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
if (!onlyIfAbsent)
e.val = value;
break;
}
Node<K,V> pred = e;
if ((e = e.next) == null) {
pred.next = new Node<K,V>(hash, key,
value, null);
break;
}
}
}
// 6.当前为红黑树，将新的键值对插入到红黑树中
else if (f instanceof TreeBin) {
Node<K,V> p;
binCount = 2;
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
// 7.插入完键值对后再根据实际大小看是否需要转换成红黑树
if (binCount != 0) {
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
//8.对当前容量大小进行检查，如果超过了临界值（实际大小*加载因子）就需要扩容
addCount(1L, binCount);
return null;
}
获取方法 get()
看完了 put 方法再来看 get 方法就很容易了，用逆向思维去看就好，这样存的话我反过来这么取就好了。get 方法源码为：
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
// 1. 重hash
int h = spread(key.hashCode());
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
// 2. table[i]桶节点的key与查找的key相同，则直接返回
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
// 3. 当前节点hash小于0说明为树节点，在红黑树中查找即可
else if (eh < 0)
return (p = e.find(h, key)) != null ? p.val : null;
//否则为链表的情况
while ((e = e.next) != null) {
//4. 从链表中查找，查找到则返回该节点的value，否则就返回null即可
if (e.hash == h &&
((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}
读操作无需加锁
ConcurrentHashMap的扩容
通过判断该节点的 hash 值是不是等于-1（MOVED）,代码为 (fh = f.hash) == MOVED，说明 Map 正在扩容。那么就帮助 Map 进行扩容。以加快速度。
helpTransfer(Node<K,V>[] tab, Node<K,V> f)就是协助扩容的方法。这里我们就能看出 ConcurrentHashMap设 计的精妙之处了，线程不仅可以进行增删改查，甚至可以去协助扩容，来减少扩容时移动数据的大量操作对阻塞时间的影响。- 让多个线程一起完成扩容，使得扩容速度非常的快，不仅仅减少了扩容需要的时间，还合理的利用了线程资源。这种想法属实太强了。
首先我们来看一下作为扩容的入口点，也就是什么时候扩容呢？
-
就是当节点的个数等于 SizeCtl 的时候扩容，扩容依旧是2倍扩容。那么统计节点个数的方法就是扩容方法的入口点：即 addCount()。
private final void addCount(long x, int check) { CounterCell[] as; long b, s; //通过CAS更新baseCount，table的数量，counterCells表示元素个数的变化 if ((as = counterCells) != null || !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) { CounterCell a; long v; int m; boolean uncontended = true; //如果多个线程都在执行，则CAS失败，执行fullAddCount，全部加入count if (as == null || (m = as.length - 1) < 0 || (a = as[ThreadLocalRandom.getProbe() & m]) == null || !(uncontended = U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) { fullAddCount(x, uncontended); return; } if (check <= 1) return; s = sumCount(); } //check>=0表示需要进行扩容操作 if (check >= 0) { Node<K,V>[] tab, nt; int n, sc; while (s >= (long)(sc = sizeCtl) && (tab = table) != null && (n = tab.length) < MAXIMUM_CAPACITY) { int rs = resizeStamp(n); if (sc < 0) { if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 || sc == rs + MAX_RESIZERS || (nt = nextTable) == null || transferIndex <= 0) break; if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) //这里才开始进入扩容。 transfer(tab, nt); } //当前线程发起操作，nextTable=null else if (U.compareAndSwapInt(this, SIZECTL, sc, (rs << RESIZE_STAMP_SHIFT) + 2)) transfer(tab, null); s = sumCount(); } } }实际上addCount的原理，很简单，统计并更新所有节点个数，更新时使用的是CAS操作。然后进行检查，查看当前是否需要扩容，如果需要扩容，进入transfer()方法中。
-
transfer（） 方法
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) { int n = tab.length, stride; if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE) stride = MIN_TRANSFER_STRIDE; // subdivide range //1. 新建Node数组，容量为之前的两倍 if (nextTab == null) { // initiating try { @SuppressWarnings("unchecked") Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1]; nextTab = nt; } catch (Throwable ex) { // try to cope with OOME sizeCtl = Integer.MAX_VALUE; return; } nextTable = nextTab; transferIndex = n; } int nextn = nextTab.length; //2. 新建forwardingNode引用，在之后会用到 ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab); boolean advance = true; boolean finishing = false; // to ensure sweep before committing nextTab for (int i = 0, bound = 0;;) { Node<K,V> f; int fh; // 3. 确定遍历中的索引i while (advance) { int nextIndex, nextBound; if (--i >= bound || finishing) advance = false; else if ((nextIndex = transferIndex) <= 0) { i = -1; advance = false; } else if (U.compareAndSwapInt (this, TRANSFERINDEX, nextIndex, nextBound = (nextIndex > stride ? nextIndex - stride : 0))) { bound = nextBound; i = nextIndex - 1; advance = false; } } //4.将原数组中的元素复制到新数组中去 //4.5 for循环退出，扩容结束修改sizeCtl属性 if (i < 0 || i >= n || i + n >= nextn) { int sc; if (finishing) { nextTable = null; table = nextTab; sizeCtl = (n << 1) - (n >>> 1); return; } if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) { if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT) return; finishing = advance = true; i = n; // recheck before commit } } //4.1 当前数组中第i个元素为null，用CAS设置成特殊节点forwardingNode(可以理解成占位符) else if ((f = tabAt(tab, i)) == null) advance = casTabAt(tab, i, null, fwd); //4.2 如果遍历到ForwardingNode节点 说明这个点已经被处理过了 直接跳过 这里是控制并发扩容的核心 else if ((fh = f.hash) == MOVED) advance = true; // already processed else { synchronized (f) { if (tabAt(tab, i) == f) { Node<K,V> ln, hn; if (fh >= 0) { //4.3 处理当前节点为链表的头结点的情况，构造两个链表，一个是原链表 另一个是原链表的反序排列 int runBit = fh & n; Node<K,V> lastRun = f; for (Node<K,V> p = f.next; p != null; p = p.next) { int b = p.hash & n; if (b != runBit) { runBit = b; lastRun = p; } } if (runBit == 0) { ln = lastRun; hn = null; } else { hn = lastRun; ln = null; } for (Node<K,V> p = f; p != lastRun; p = p.next) { int ph = p.hash; K pk = p.key; V pv = p.val; if ((ph & n) == 0) ln = new Node<K,V>(ph, pk, pv, ln); else hn = new Node<K,V>(ph, pk, pv, hn); } //在nextTable的i位置上插入一个链表 setTabAt(nextTab, i, ln); //在nextTable的i+n的位置上插入另一个链表 setTabAt(nextTab, i + n, hn); //在table的i位置上插入forwardNode节点 表示已经处理过该节点 setTabAt(tab, i, fwd); //设置advance为true 返回到上面的while循环中 就可以执行i--操作 advance = true; } //4.4 处理当前节点是TreeBin时的情况，操作和上面的类似 else if (f instanceof TreeBin) { TreeBin<K,V> t = (TreeBin<K,V>)f; TreeNode<K,V> lo = null, loTail = null; TreeNode<K,V> hi = null, hiTail = null; int lc = 0, hc = 0; for (Node<K,V> e = t.first; e != null; e = e.next) { int h = e.hash; TreeNode<K,V> p = new TreeNode<K,V> (h, e.key, e.val, null, null); if ((h & n) == 0) { if ((p.prev = loTail) == null) lo = p; else loTail.next = p; loTail = p; ++lc; } else { if ((p.prev = hiTail) == null) hi = p; else hiTail.next = p; hiTail = p; ++hc; } } ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) : (hc != 0) ? new TreeBin<K,V>(lo) : t; hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) : (lc != 0) ? new TreeBin<K,V>(hi) : t; setTabAt(nextTab, i, ln); setTabAt(nextTab, i + n, hn); setTabAt(tab, i, fwd); advance = true; } } } } } }
扩容总结： 整个扩容操作分为两个部分
- 第一部分：构建一个
nextTable,它的容量是原来的两倍，这个操作是单线程完成的。新建 table 数组的代码为：Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1]，在原容量大小的基础上右移一位。 - 第二个部分：就是将原来 table 中的元素复制到 nextTable 中，主要是遍历复制的过程。
在进行第二部分遍历复制时，根据运算得到当前遍历的数组的位置 i，然后利用 tabAt 方法获得 i 位置的元素再进行判断：
- 1、如果这个位置为空，就在原 table 中的 i 位置放入
forwardNode 节点，这个也是触发并发扩容的关键点。 - 2、如果这个位置是 Node 节点（fh>=0），如果它是一个链表的头节点，就构造一个反序链表，把他们分别放在 nextTable 的 i 和 i+n 的位置上。== 头插法==
- 3、如果这个位置是 TreeBin 节点（fh<0），也做一个反序处理，并且判断是否需要 untreefi，把处理的结果分别放在 nextTable 的 i 和 i+n 的位置上。
- 4、遍历过所有的节点以后就完成了复制工作，这时让 nextTable 作为新的 table，并且更新 sizeCtl 为新容量的 0.75 倍 ，完成扩容。
HashMap、Hashtable、ConccurentHashMap三者的区别
-
HashMap： 非线程安全，允许NULL值与NULL键。默认大小为16，扩容为2倍扩容。
-
HashTable： 线程安全，不允许NULL值与NULL键，默认大小为11，扩容为2倍+1扩容。HashTable的线程安全实现依靠Synchronized。
-
ConcurrentHashMap： 线程安全，不允许NULL值与NULL键，默认大小为16，扩容为2倍扩容。ConcurrentHashMap的线程安全实现依靠于
Synchronized + CAS。 -
HashMap不应用于并发场景，会产生死循环，HashTable于ConcurrentHashMap运用于并发场景，但是两者有性能差距。当数据量足够大时，我们会发现ConcurrentHashMap的效率实际上比HashTable要低下一些，但是关于读操作，ConcurrentHashMap比HashTable快不止一个量级。
-
Collections.synchronizedMap(new HashMap());
四、CopyOnWriteArrayList
基本思路
在很多应用场景中，读操作可能会远远大于写操作。由于读操作根本不会修改原有的数据，因此如果每次读取都进行加锁操作，其实是一种资源浪费。我们应该允许多个线程同时访问 List 的内部数据，毕竟读操作是线程安全的。
- 这和
ReentrantReadWriteLock读写锁的思想非常类似，也就是 读读共享、写写互斥、读写互斥、写读互斥 - 了将读取的性能发挥到极致，CopyOnWriteArrayList 读取是完全不用加锁的：写入也不会阻塞读取操作，只有写入和写入之间需要进行同步等待，读操作的性能得到大幅度提升。
核心思想： CopyOnWriteArrayList 类的所有可变操作（add，set等等）都是通过创建底层数组的新副本来实现的。当 List 需要被修改的时候，并不直接修改原有数组对象，而是对原有数据进行一次拷贝，将修改的内容写入副本中。写完之后，再将修改完的副本替换成原来的数据，这样就可以保证写操作不会影响读操作了。
读取操作的实现
读取操作没有任何同步控制和锁操作，理由就是内部数组 array 不会发生修改，只会被另外一个 array 替换，因此可以保证数据安全。
/** The array, accessed only via getArray/setArray. */
private transient volatile Object[] array;
public E get(int index) {
return get(getArray(), index);
}
@SuppressWarnings("unchecked")
private E get(Object[] a, int index) {
return (E) a[index];
}
final Object[] getArray() {
return array;
}
写入操作的实现
CopyOnWriteArrayList 写入操作 add() 方法在添加集合的时候加了锁，保证同步，避免多线程写的时候会 copy 出多个副本。
/**
* 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(); // 释放锁
}
}
- 复制副本进行操作的目的是方式其他读线程进行脏读。
- 加锁的目的是防止其他写线程中断写进程。
- 将数组用 volatile 进行修饰，是因为 volatile 具有可见性。其他线程总能够看到 volatile 变量的最后写入。volatile的可见性是通过 JVMM 实现的，当变量进行修改后，会从工作内存刷新到主物理内存中。其他线从可以理解立即知道，并且提出更新
优缺点
CopyOnWriteArrayList 相当于线程安全的 ArrayList。和 ArrayList 一样，它是个可变数组；但是和ArrayList 不同的时，它具有以下特性：
- 它最适合于具有以下特征的应用程序：List 大小通常保持很小，只读操作远多于可变操作，需要在遍历期间防止线程间的冲突。
- 它是线程安全的。
- 因为通常需要复制整个基础数组，所以可变操作（add()、set() 和 remove()等等）的开销很大。
- 迭代器支持 hasNext(), next()等不可变操作，但不支持可变 remove()等操作。
- 使用迭代器进行遍历的速度很快，并且不会与其他线程发生冲突。在构造迭代器时，迭代器依赖于不变的数组快照。
扫一扫
1557
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
