自分を忘れて他人を愛するだけで、静かに、幸せに、高貴になることができます。-トルストイ、アンナカレニーナ
0序文
スレッドセーフなMap-ConcurrentHashMapでは、HashMapとの違いを調べてみましょう。なぜスレッドセーフを確保できるのでしょうか。
1継承体系
2プロパティ
- Bin配列。初期化は最初の挿入後にのみ遅延します。サイズは常に2の累乗です。イテレータによって直接アクセスされます。
画像のタイトル - 使用する次のテーブル。展開時のみnull以外
画像のタイトル - 基本的なカウンター値。主に競合がない場合に使用され、テーブルの初期化競争中のフィードバックとしても使用されます。CAS経由で更新
画像のタイトル - テーブルの初期化と拡張の制御が負の場合、テーブルは初期化または拡張されます。-1は、アクティブな拡張スレッドの数-Nを初期化するために使用されます。それ以外の場合、テーブルがnullの場合、作成時に使用される初期テーブルサイズ、またはデフォルトを保持します初期化後、次の拡張テーブルの要素カウント値を保持します。
画像のタイトル - 拡張時に分割される次のテーブルのインデックス（プラス1）
画像のタイトル - CounterCellの作成時に使用される展開および/またはスピンロック（CAS経由でロック）
画像のタイトル - カウンターセルの表。null以外の場合、サイズは2の累乗です。
画像のタイトル - ノード：キー、値、およびキーハッシュ値を保持するデータ構造。値と次の両方が揮発性で変更され、可視性が確保されます。
画像のタイトル - 特別なノードノード。転送ノードのハッシュ値はMOVED、-1です。これには、nextTableの参照が格納されます。転送中にビンヘッドに挿入されるノード。ForwardingNodeは、テーブルが展開されたときのプレースホルダーとしてのみ機能します。シンボルはテーブルに配置され、現在のノードがnullであるか、移動されたことを示します。
画像のタイトル
3工法
3.1パラメータなし
- デフォルトの初期テーブルサイズ（16）を使用して新しい空のマップを作成します
画像のタイトル
3.2参加
- サイズを動的に調整する必要なく、指定された数の要素に対応できる初期テーブルサイズを持つ新しい空のマップを作成します。
画像のタイトル 画像のタイトル
sizeCtlは一時的に2の累乗の値の容量を維持することに注意してください。
パラメータを使用してConcurrentHashMapをインスタンス化すると、テーブルのサイズがパラメータに従って調整されます。パラメータを100とすると、最終的には256に調整され、テーブルのサイズが常に2の累乗になるようにします。
tableSizeFor
- 指定された必要な容量について、テーブルサイズを2の累乗で返します
画像のタイトル
テーブルの遅延初期化
ConcurrentHashMapはコンストラクターでsizeCtl値を初期化するだけで、テーブルを直接初期化しませんが、最初のputオペレーションテーブルの初期化を遅らせます。ただし、putは同時に実行できます。テーブルが1回だけ初期化されるようにする方法は？
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
// 进入自旋
while ((tab = table) == null || tab.length == 0) {
// 若某线程发现sizeCtl<0，意味着其他线程正在初始化，当前线程让出CPU时间片
if ((sc = sizeCtl) < 0)
Thread.yield(); // 失去初始化的竞争机会; 直接自旋
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
// 有可能执行至此时，table 已经非空，所以做双重检验
if ((tab = table) == null || tab.length == 0) {
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}
复制代码最初のputオペレーションを実行するスレッドはUnsafe.compareAndSwapIntメソッドを実行してsizeCtlを-1に変更し、他のスレッドはThread.yield（）を介してCPUタイムスライスのみを放棄して、テーブルの初期化が完了するのを待つことができます。
4枚入れ
テーブルが初期化され、書き込み操作はCAS +同期を使用して、同時挿入または更新操作を実装します。
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
// 计算hash
int hash = spread(key.hashCode());
int binCount = 0;
// 自旋保证可以新增成功
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
// step1. table 为 null或空时进行初始化
if (tab == null || (n = tab.length) == 0)
tab = initTable();
// step 2. 若当前数组索引无值，直接创建
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
// CAS 在索引 i 处创建新的节点，当索引 i 为 null 时，即能创建成功，结束循环,否则继续自旋
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
// step3. 若当前桶为转移节点，表明该桶的点正在扩容，一直等待扩容完成
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
// step4. 当前索引位置有值
else {
V oldVal = null;
// 锁定当前槽点,保证只会有一个线程能对槽点进行修改
synchronized (f) {
// 这里再次判断 i 位置数据有无被修改
// binCount 被赋值，说明走到了修改表的过程
if (tabAt(tab, i) == f) {
// 链表
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;
}
}
}
// 红黑树，这里没有使用 TreeNode,使用的是 TreeBin，TreeNode 只是红黑树的一个节点
// TreeBin 持有红黑树的引用，并且会对其加锁，保证其操作的线程安全
else if (f instanceof TreeBin) {
Node<K,V> p;
binCount = 2;
// 满足if的话，把老的值给oldVal
// 在putTreeVal方法里面，在给红黑树重新着色旋转的时候
// 会锁住红黑树的根节点
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
// binCount不为空，并且 oldVal 有值的情况，说明已新增成功
if (binCount != 0) {
// 链表是否需要转化成红黑树
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
// 槽点已经上锁，只有在红黑树或者链表新增失败的时候
// 才会走到这里，这两者新增都是自旋的，几乎不会失败
break;
}
}
}
// step5. check 容器是否需要扩容，如果需要去扩容，调用 transfer 方法扩容
// 如果已经在扩容中了，check有无完成
addCount(1L, binCount);
return null;
}
复制代码4.2実行プロセス
- 配列が空の場合は初期化し、完了したら2に進みます。
- 現在のバケットに値があるかどうかを計算します
- なし、CASが作成され、失敗した後、成功するまでスピンし続ける
- はい、3に進みます
- バケットが転送ノードであるかどうかを判断する（容量拡張）
- はい、それは回転して拡張が完了するのを待っており、その後追加されました
- いいえ、4に進みます
- バケットに値があります。現在のバケットに同期ロックを追加してください
- リンクリスト、チェーンの最後にノードを追加
- 赤と黒の木、赤と黒の木バージョンの新しい方法
- 追加が完了したら、拡張が必要かどうかを確認します
スピン+ CAS +同期によって3つの軸をロックする実装は非常に賢く、並行コードを設計するためのベストプラクティスを提供します。
5転送拡張
putメソッドの最後に展開が必要かどうかを確認するには、putメソッドのaddCountメソッドから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
// 如果新数组为空，初始化，大小为原数组的两倍，n << 1
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;
// 若原数组上是转移节点，说明该节点正在被扩容
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
boolean advance = true;
boolean finishing = false; // to ensure sweep before committing nextTab
// 自旋，i 值会从原数组的最大值递减到 0
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
while (advance) {
int nextIndex, nextBound;
// 结束循环的标志
if (--i >= bound || finishing)
advance = false;
// 已经拷贝完成
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
// 每次减少 i 的值
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
bound = nextBound;
i = nextIndex - 1;
advance = false;
}
}
// if 任意条件满足说明拷贝结束了
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
}
}
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
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) {
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);
}
// 在新数组位置上放置拷贝的值
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
// 在老数组位置上放上 ForwardingNode 节点
// put 时，发现是 ForwardingNode 节点，就不会再动这个节点的数据了
setTabAt(tab, i, fwd);
advance = true;
}
// 红黑树的拷贝
else if (f instanceof TreeBin) {
// 红黑树的拷贝工作，同 HashMap 的内容，代码忽略
...
// 在老数组位置上放上 ForwardingNode 节点
setTabAt(tab, i, fwd);
advance = true;
}
}
}
}
}
}
复制代码実行プロセス
- 最初に、元の配列のすべての値を拡張後に新しい配列にコピーし、最初に配列の最後からコピーします
- アレイのスロットをコピーするときは、最初に元のアレイのスロットをロックします。新しいアレイに正常にコピーするときは、元のアレイのスロットを転送ノードに割り当てます
- このとき、スロットに入れる必要のある新しいデータがある場合、そのスロットは転送ノードであることがわかり、常に待機するため、拡張が完了するまでスロットに対応するデータは変化しません。
- 配列の末尾から先頭にコピーします。コピーが成功するたびに、すべての配列データが新しい配列にコピーされるまで、元の配列のノードが転送ノードとして設定されます。配列全体が配列コンテナーに直接割り当てられ、コピーが完了します。
6まとめ
コンカレントマップとしてのConcurrentHashMapは、インタビューで必要なポイントであり、ジョブでマスターする必要があるコンカレントコンテナーです。