ConcurrentHashMap 兩個版本讀源碼筆記

JDK 1.7

數據結構

JDK 1.7 結構

Segment 分段鎖

依舊是數組+鏈表，Segment 是一個 ReentrantLock 可重入鎖：

static final class Segment<K,V> extends ReentrantLock implements Serializable

數據操作的時候，先定位到 Segment 數組的位置，然后嘗試獲取鎖。某個線程獲取鎖成功就進行數據添加、移除等操作，這時其它線程需要操作數據，會進入 Segment 的鎖隊列（AQS）并根據情況進入阻塞狀態。等待獨占線程釋放鎖后，后面的線程接著進行數據操作。

每一個 Segment 都是一個鎖，各個鎖之間互不影響。也就是當 Segment A 被某線程操作數據的時候，Segment B 依舊可以進行數據操作，這就是所謂 “鎖分離” 的大概原理。這樣分段鎖的效率要高于整個數據加鎖、也高于 synchronized 對方法加鎖。

元素個體 HashEntry

HashEntry 數組是真正存放數據的地方：

static final class HashEntry<K,V> {
    final int hash; // hash值
    final K key; // key
    volatile V value; // value
    volatile HashEntry<K,V> next; // 下一個結點

    HashEntry(int hash, K key, V value, HashEntry<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }
}

要注意的是 value 和 next 結點都是 volatile 修飾的，保證了其可見性，也就是在讀取的時候都是最新的值。

構造器

/**
 * 默認的初始容量 16
 */
static final int DEFAULT_INITIAL_CAPACITY = 16;
/**
 * 默認的負載因子
 */
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
 * 默認的并發數量,會影響segments數組的長度(初始化后不能修改)
 */
static final int DEFAULT_CONCURRENCY_LEVEL = 16;
/**
 * 最大容量,構造ConcurrentHashMap時指定的值超過,就用該值替換
 * ConcurrentHashMap大小必須是2^n,且小于等于2^30
 */
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
 * 允許最大segment數量,用于限定concurrencyLevel的邊界,必須是2^n
 */
static final int MAX_SEGMENTS = 1 << 16;
/**
 * 非鎖定情況下調用size和contains方法的重試次數,避免由于table連續被修改導致無限重試
 */
static final int RETRIES_BEFORE_LOCK = 2;
/**
 * segments數組
 */
final Segment<K,V>[] segments;

構造器可指定默認初始容量，增長因子，并發等級（決定同一時間允許線程操作的數據）。

public ConcurrentHashMap(int initialCapacity,
                         float loadFactor, int concurrencyLevel) {
    if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
        throw new IllegalArgumentException();
    // MAX_SEGMENTS 為最大 Segment 數量，默認 1<<16=65536
    // 如果超過了最大容量，直接設置為最大
    if (concurrencyLevel > MAX_SEGMENTS)
        concurrencyLevel = MAX_SEGMENTS;
    // 找到距離并發數最大的 2 的冪數，作為 Segment 數組的容量
    int sshift = 0;
    int ssize = 1;
    while (ssize < concurrencyLevel) {
        ++sshift;
        ssize <<= 1;
    }
    this.segmentShift = 32 - sshift;
    this.segmentMask = ssize - 1;
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    int c = initialCapacity / ssize;
    if (c * ssize < initialCapacity)
        ++c;
    int cap = MIN_SEGMENT_TABLE_CAPACITY;
    while (cap < c)
        cap <<= 1;
    // 根據傳來的參數，創建 Segment 模板 s0
    // 放置元素時需要初始化 Segment，需要用到這個模板
    Segment<K,V> s0 =
        new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
                         (HashEntry<K,V>[])new HashEntry<?,?>[cap]);
    Segment<K,V>[] ss = (Segment<K,V>[])new Segment<?,?>[ssize];
    UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
    this.segments = ss;
}

數據存放

public V put(K key, V value) {
    Segment<K,V> s;
    // value 不可為 null
    if (value == null)
        throw new NullPointerException();
    // key 不可為 null，否則 hashCode 方法空指針
    int hash = hash(key.hashCode());
    // hash 碼進行運算，相當于擾動一下
    int j = (hash >>> segmentShift) & segmentMask;
    // 根據 hash 值獲取對應的 Segment
    if ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck
         (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment
        s = ensureSegment(j);
    return s.put(key, hash, value, false);
}

  1. ConcurrentHashMap 鍵值不可為 null。至于為什么這么設計，有一種說法是為了避免多線程下獲取數據，無法區分到底是沒有該數據，還是該數據為 null 的情況。

  2. 定位 Segment 位置，如果不存在則創建 Segment。

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;
                HashEntry<K,V> first = entryAt(tab, index);
                // 遍歷鏈表
                for (HashEntry<K,V> e = first;;) {
                    if (e != null) { // 鏈表結點不為空
                        K k;
                        // key 相同則準備覆蓋值，覆蓋成功跳出循環
                        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 {// 鏈表頭結點為空
                        // 不為 null 
                        if (node != null)
                            // 將新結點放進鏈表首位，調用 putOrderedObject 進行內存地址偏移確定位置
                            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
                            // 頭結點放在下標處，會調用 putOrderedObject 確定位置
                            setEntryAt(tab, index, node);
                        ++modCount;
                        count = c;
                        oldValue = null;
                        break;
                    }
                }
            } finally {
                // 最后釋放鎖
                unlock();
            }
            return oldValue;
        }
  1. 某個線程來到該方法，首先嘗試獲取鎖。獲取成功執行后續 put 操作，失敗進行自旋嘗試獲取。如果重試次數最大則進入 AQS 隊列，再根據其狀態進行阻塞或中斷等待獲取。

scanAndLockForPut 再次嘗試獲取鎖或阻塞。

private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
            HashEntry<K,V> first = entryForHash(this, hash);
            HashEntry<K,V> e = first;
            HashEntry<K,V> node = null;
            int retries = -1; // negative while locating node
            while (!tryLock()) {
                HashEntry<K,V> f; // to recheck first below
                if (retries < 0) {
                    if (e == null) {
                        if (node == null) // speculatively create node
                            node = new HashEntry<K,V>(hash, key, value, null);
                        retries = 0;
                    }
                    else if (key.equals(e.key))
                        retries = 0;
                    else
                        e = e.next;
                }
                else if (++retries > MAX_SCAN_RETRIES) {
                    lock();// 進入 ReetLock 的 lock 方法，會進行排隊或阻塞
                    break;
                }
                else if ((retries & 1) == 0 &&
                         (f = entryForHash(this, hash)) != first) {
                    e = first = f; // re-traverse if entry changed
                    retries = -1;
                }
            }
            return node;
        }
  1. 根據 hash 計算出下標，根據下標定位 HashEntry 數組的位置，新增的元素即將插入該位置并作為頭結點。
  2. 緊接著遍歷鏈表，如果新元素下標與已存在的相同，則覆蓋值并退出循環。
  3. 遍歷出現 null 的情況，要么是空桶、要么是遍歷完了鏈表。然后將新增的元素添加到鏈表首位，UNSAFE.putOrderedObject(tab, ((long)i << TSHIFT) + TBASE, e) 相當于把數據存放到合適的地址中去。

確定容量

每個 Segment 進行數據存放或刪除時，會統計 modCount（編輯次數）和 count（元素數量）。

計算 size 時，進行三次遍歷。如果最后兩次的 modCount 相同說明近期沒有發生數據變化，可以樂觀的認為計算出的 count 就是最終數量。

如果最后兩次統計的 modCount 不一致，說明近期數據可能發生了變化。只能把每個 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;
    final int segmentCount = segments.length;

    long previousSum = 0L;
    for (int retries = -1; retries < RETRIES_BEFORE_LOCK; retries++) {
        long sum = 0L;    // sum of modCounts
        long size = 0L;
        for (int i = 0; i < segmentCount; i++) {
            Segment<K,V> segment = segmentAt(segments, i);
            if (segment != null) {
                sum += segment.modCount;
                size += segment.count;
            }
        }
        if (sum == previousSum)
            return ((size >>> 31) == 0) ? (int) size : Integer.MAX_VALUE;
        previousSum = sum;
    }

    long size = 0L;
    for (int i = 0; i < segmentCount; i++) {
        Segment<K,V> segment = ensureSegment(i);
        segment.lock();
        size += segment.count;
    }
    for (int i = 0; i < segmentCount; i++)
        segments[i].unlock();
    return ((size >>> 31) == 0) ? (int) size : Integer.MAX_VALUE;
}

擴容機制 rehash

當數組容量到達一定值(threshold)時，進行擴容。

if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                            rehash(node);

threshold = 數組容量*增長因子。

private void rehash(HashEntry<K,V> node) {
    HashEntry<K,V>[] oldTable = table;
    int oldCapacity = oldTable.length; // 舊數組長度
    int newCapacity = oldCapacity << 1; // 翻倍
    threshold = (int)(newCapacity * loadFactor); // 新的閾值（大于該值擴容）
    HashEntry<K,V>[] newTable =
        (HashEntry<K,V>[]) new HashEntry<?,?>[newCapacity]; // 創建新數組
    int sizeMask = newCapacity - 1; // 生成新掩碼，用于生成下標
    for (int i = 0; i < oldCapacity ; i++) {
        HashEntry<K,V> e = oldTable[i];
        if (e != null) {
            HashEntry<K,V> next = e.next;
            int idx = e.hash & sizeMask; // 根據 hash 和新的掩碼生成下標
            if (next == null)   //  只有一個元素的鏈表，直接放就好
                newTable[idx] = e;
            else { // 不止一個元素，遍歷它，重新確定位置
                HashEntry<K,V> lastRun = e; // 標記原來的結點
                int lastIdx = idx; // 標記原來的值
                for (HashEntry<K,V> last = next;
                     last != null;
                     last = last.next) {
                    int k = last.hash & sizeMask;
                    if (k != lastIdx) { // 新的下標和原來的下標不一樣，標記一下
                        lastIdx = k;
                        lastRun = last; // 標記一下位置發生變化的結點，后續遍歷重新放置位置
                    }
                }
                newTable[lastIdx] = lastRun;
                // 如果 p==lastRun 說明所有元素下標都未發生變化，也就不需要遍歷了
                // 反之，把發生變化的鏈表位置重新歸置一下
                for (HashEntry<K,V> p = e; p != lastRun; p = p.next) {
                    V v = p.value;
                    int h = p.hash;
                    int k = h & sizeMask;
                    HashEntry<K,V> n = newTable[k];
                    newTable[k] = new HashEntry<K,V>(h, p.key, v, n);
                }
            }
        }
    }
    // 把新加入的結點作為首節點放置
    int nodeIndex = node.hash & sizeMask; // add the new node
    node.setNext(newTable[nodeIndex]);
    newTable[nodeIndex] = node;
    table = newTable;
}

因為擴容之前已經進行了加鎖處理，所以無需考慮同步問題。

get 獲取元素

get 的過程是不加鎖的，效率較高。首先根據 hash 值定位到 Segment 位置，然后再進行鏈表的遍歷直到搜索到元素即可。

public V get(Object key) {
    Segment<K,V> s; // manually integrate access methods to reduce overhead
    HashEntry<K,V>[] tab;
    int h = hash(key.hashCode());
    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) {
             // 弱一致性的的原因，遍歷時該 Segment 可能已經更新
             // contains 方法也有同樣的問題
            K k;
            if ((k = e.key) == key || (e.hash == h && key.equals(k)))
                return e.value;
        }
    }
    return null;
}

為什么 get 過程不加鎖，首先獲取 Segment 的時使用的 UNSAFE.getObjectVolatile 方法，進行 volatile語義的讀取。volatile 讀取保證了該 Segment 在讀取時是最新的，但是在遍歷的時候，原 Segment 可能已經發生了變化，在使用時需要注意。

remove 移除元素

同樣是先找到相應的 Segment，然后加鎖進行移除，移除完畢釋放鎖。

public V remove(Object key) {
    int hash = hash(key.hashCode());
    Segment<K,V> s = segmentForHash(hash);
    return s == null ? null : s.remove(key, hash, null);
}

final V remove(Object key, int hash, Object value) {
 if (!tryLock())
        scanAndLock(key, hash);
    V oldValue = null;
    try {
        HashEntry<K,V>[] tab = table;
        int index = (tab.length - 1) & hash;
        HashEntry<K,V> e = entryAt(tab, index);
        HashEntry<K,V> pred = null;
        while (e != null) {
            K k;
            HashEntry<K,V> next = e.next;
            if ((k = e.key) == key ||
                (e.hash == hash && key.equals(k))) {
                V v = e.value;
                if (value == null || value == v || value.equals(v)) {
                    if (pred == null)
                        setEntryAt(tab, index, next);
                    else
                        pred.setNext(next);
                    ++modCount;
                    --count;
                    oldValue = v;
                }
                break;
            }
            pred = e;
            e = next;
        }
    } finally {
        unlock();
    }
    return oldValue;
}

JDK 1.8

數據結構

不再采用多個 Segment 結構，而是 Node 數組+鏈表/紅黑樹來存儲數據。這樣做優化了查詢速度，由原來的鏈表查詢 O(n) 優化為紅黑樹 O(logn)。

JDK 1.8 數據結構

元素個體：Node<K,V>

Node 結點的值 val 和 下一個結點 Node 都是 volatile 修飾的，保證了可見性（保證讀取時是最新的）。

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    volatile V val;
    volatile Node<K,V> next;

    Node(int hash, K key, V val, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.val = val;
        this.next = next;
    }

    public final K getKey()     { return key; }
    public final V getValue()   { return val; }
    public final int hashCode() { return key.hashCode() ^ val.hashCode(); }
    public final String toString() {
        return Helpers.mapEntryToString(key, val);
    }
    ...

構造器

構造器之一，參數最多就貼出來。

public ConcurrentHashMap(int initialCapacity,
                         float loadFactor, int concurrencyLevel) {
    if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
        throw new IllegalArgumentException();
    if (initialCapacity < concurrencyLevel)   // Use at least as many bins
        initialCapacity = concurrencyLevel;   // as estimated threads
    long size = (long)(1.0 + (long)initialCapacity / loadFactor);
    int cap = (size >= (long)MAXIMUM_CAPACITY) ?
        MAXIMUM_CAPACITY : tableSizeFor((int)size);
    this.sizeCtl = cap;
}
  • initialCapacity：指定初始容量，默認的是 16。需要注意的是當初始容量小于并發數量，會直接等于并發數。
  • loadFactor：指定閾值，當容量大于該值進行擴容。
  • concurrencyLevel：并發數。

數據存放

final V putVal(K key, V value, boolean onlyIfAbsent) {
    // 不可為 null
    if (key == null || value == null) throw new NullPointerException();
    // 1. hash 值處理
    int hash = spread(key.hashCode());
    int binCount = 0;
    // 遍歷
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        if (tab == null || (n = tab.length) == 0)
            2. 初始化
            tab = initTable();
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {// volaite 讀取，要插入的位置為 null 說明當前下標沒有數據，可創建頭結點
            // CAS 插入數據，期望值 null 要修改的值新 Node
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                break;                   // no lock when adding to empty bin
        }
        // 3. 正在擴容
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        else {
            V oldVal = null;
            // 4. volatile 只保證了 Node 值和下一個結點的可見性，并不保證原子性
            // 所以需要加鎖
            synchronized (f) {
                // 找到結點下標位置
                if (tabAt(tab, i) == f) {
                    if (fh >= 0) {
                        binCount = 1;
                        // 遍歷這串鏈表
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            // key 相同，覆蓋 value
                            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;
                            }
                        }
                    }
                    // 添加樹節點
                    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;
                        }
                    }
                    else if (f instanceof ReservationNode)
                        throw new IllegalStateException("Recursive update");
                }
            }
            if (binCount != 0) {
                // 超過 8 個轉換為紅黑樹
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    // 5. 容量計算
    addCount(1L, binCount);
    return null;
}
  1. spread 方法先進行高 16 位與低 16 位進行異或，進行擾動。然后再和 HASH_BITS 進行 & 運算，也就是與 0111 1111X7 進行 & 運算，保證 hash 值不為負數順便又進行一次擾動。
    因為負數定位了一些數據正在參與擴容、樹節點轉換、反轉等信息，避免沖突。
static final int HASH_BITS = 0x7fffffff;
static final int spread(int h) {
     return (h ^ (h >>> 16)) & HASH_BITS;
 }
  1. table 為空的初始化，經典的 自旋+CAS。如果有線程正在初始化，則 CAS 標記一個數值表示正在初始化。當別的線程進來時，發現正在初始化，則 yield 讓出 CPU。下次再進入自旋循環時，可能已經初始化完畢，進行后面的 put 操作了。
private final Node<K,V>[] initTable() {
    Node<K,V>[] tab; int sc;
    while ((tab = table) == null || tab.length == 0) {
        if ((sc = sizeCtl) < 0) // 小于 0 說明可能正在初始化中，轉換為就緒狀態，讓出 cpu
            Thread.yield(); // lost initialization race; just spin
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {// CAS 一下，期望值 sc，要修改的值 -1。保證其它線程來到這里時不會影響正常初始化
            try {
                if ((tab = table) == null || tab.length == 0) {
                    // 默認 16
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                    @SuppressWarnings("unchecked")
                    Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                    table = tab = nt;
                    // 減去除以 4，相當于 %75
                    sc = n - (n >>> 2);
                }
            } finally {
                sizeCtl = sc;
            }
            break;
        }
    }
    return tab;
}

  1. 如果 hash 值為 MOVE，說明正在擴容

  2. 結點加同步，之后無非就是進行遍歷。查詢新插入的 key 是否重復，如果重復覆蓋值。

  3. 容量計算，ConCurrentHashMap 使用一個 volatile 的 baseCount 來表示當前修改過后元素的個數。

private transient volatile long baseCount;

容量計算

ConCurrentHashMap 使用 CounterCells[] 數組和 baseCount 來存放和計算容量：

final long sumCount() {
    CounterCell[] as = counterCells; CounterCell a;
    long sum = baseCount;
    // 初始容量和遍歷 CounterCell 數組存儲的數量
    if (as != null) {
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                sum += a.value;
        }
    }
    return sum;
}

CounterCells 對象包含一個數量屬性，CounterCells 數組所有元素的數量屬性加起來再加上 ConCurrentHashMap 的 baseCount 就是容量了。

CounterCells 初始化時默認容量是 2。當一個線程添加數據時，首先生成線程的哈希指針（相當于隨機數，但是比 Radom 性能要好），然后將哈希指針和 CounterCells 容量-1 進行 & 運算。這與 HashMap 確認下標的過程類似，然后將創建 CounterCells 對象設置容量，再賦值到 CounterCells 數組中。

擴容機制

擴容條件：當前容量超過閾值。
transfer 當容量不足時進行擴容。這塊內容比較復雜，暫時略過。

private final void addCount(long x, int check) {
    ...
    if (check >= 0) {
        Node<K,V>[] tab, nt; int n, sc;
        // s 是計算出的元素數量，超過閾值 sizeCtl 觸發擴容
        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);
            }
            else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                         (rs << RESIZE_STAMP_SHIFT) + 2))
                transfer(tab, null);
            s = sumCount();
        }
    }
}

get 獲取元素

public V get(Object key) {
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
    int h = spread(key.hashCode());
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (e = tabAt(tab, (n - 1) & h)) != null) {
        if ((eh = e.hash) == h) {
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;
        }
        else if (eh < 0)
            return (p = e.find(h, key)) != null ? p.val : null;
        while ((e = e.next) != null) {
            if (e.hash == h &&
                ((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }
    return null;
}

get 比較簡單，先確認 hash 桶的位置，然后遍歷直到找到并返回 value 為止。找不到返回 null。

這個過程無需加鎖，效率較高。因為 Node 結點的 value 是 volatile 修飾的，保證了讀取的可見性。

?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。
  • 人面猴
    序言：七十年代末，一起剝皮案震驚了整個濱河市，隨后出現的幾起案子，更是在濱河造成了極大的恐慌，老刑警劉巖，帶你破解...
    沈念sama閱讀 227,797評論 6贊 531
  • 死咒
    序言：濱河連續發生了三起死亡事件，死亡現場離奇詭異，居然都是意外死亡，警方通過查閱死者的電腦和手機，發現死者居然都...
    沈念sama閱讀 98,179評論 3贊 414
  • 救了他兩次的神仙讓他今天三更去死
    文/潘曉璐 我一進店門，熙熙樓的掌柜王于貴愁眉苦臉地迎上來，“玉大人，你說我怎么就攤上這事。” “怎么了？”我有些...
    開封第一講書人閱讀 175,628評論 0贊 373
  • 道士緝兇錄：失蹤的賣姜人
    文/不壞的土叔 我叫張陵，是天一觀的道長。 經常有香客問我，道長，這世上最難降的妖魔是什么？ 我笑而不...
    開封第一講書人閱讀 62,642評論 1贊 309
  • ?港島之戀（遺憾婚禮）
    正文 為了忘掉前任，我火速辦了婚禮，結果婚禮上，老公的妹妹穿的比我還像新娘。我一直安慰自己，他們只是感情好，可當我...
    茶點故事閱讀 71,444評論 6贊 405
  • 惡毒庶女頂嫁案：這布局不是一般人想出來的
    文/花漫 我一把揭開白布。 她就那樣靜靜地躺著，像睡著了一般。 火紅的嫁衣襯著肌膚如雪。 梳的紋絲不亂的頭發上，一...
    開封第一講書人閱讀 54,948評論 1贊 321
  • 城市分裂傳說
    那天，我揣著相機與錄音，去河邊找鬼。 笑死，一個胖子當著我的面吹牛，可吹牛的內容都是我干的。 我是一名探鬼主播，決...
    沈念sama閱讀 43,040評論 3贊 440
  • 雙鴛鴦連環套：你想象不到人心有多黑
    文/蒼蘭香墨 我猛地睜開眼，長吁一口氣：“原來是場噩夢啊……” “哼！你這毒婦竟也來了？” 一聲冷哼從身側響起，我...
    開封第一講書人閱讀 42,185評論 0贊 287
  • 萬榮殺人案實錄
    序言：老撾萬榮一對情侶失蹤，失蹤者是張志新（化名）和其女友劉穎，沒想到半個月后，有當地人在樹林里發現了一具尸體，經...
    沈念sama閱讀 48,717評論 1贊 333
  • ?護林員之死
    正文 獨居荒郊野嶺守林人離奇死亡，尸身上長有42處帶血的膿包…… 初始之章·張勛 以下內容為張勛視角 年9月15日...
    茶點故事閱讀 40,602評論 3贊 354
  • ?白月光啟示錄
    正文 我和宋清朗相戀三年，在試婚紗的時候發現自己被綠了。 大學時的朋友給我發了我未婚夫和他白月光在一起吃飯的照片。...
    茶點故事閱讀 42,794評論 1贊 369
  • 活死人
    序言：一個原本活蹦亂跳的男人離奇死亡，死狀恐怖，靈堂內的尸體忽然破棺而出，到底是詐尸還是另有隱情，我是刑警寧澤，帶...
    沈念sama閱讀 38,316評論 5贊 358
  • ?日本核電站爆炸內幕
    正文 年R本政府宣布，位于F島的核電站，受9級特大地震影響，放射性物質發生泄漏。R本人自食惡果不足惜，卻給世界環境...
    茶點故事閱讀 44,045評論 3贊 347
  • 男人毒藥：我在死后第九天來索命
    文/蒙蒙 一、第九天 我趴在偏房一處隱蔽的房頂上張望。 院中可真熱鬧，春花似錦、人聲如沸。這莊子的主人今日做“春日...
    開封第一講書人閱讀 34,418評論 0贊 26
  • 一樁弒父案，背后竟有這般陰謀
    文/蒼蘭香墨 我抬頭看了看天上的太陽。三九已至，卻和暖如春，著一層夾襖步出監牢的瞬間，已是汗流浹背。 一陣腳步聲響...
    開封第一講書人閱讀 35,671評論 1贊 281
  • 情欲美人皮
    我被黑心中介騙來泰國打工， 沒想到剛下飛機就差點兒被人妖公主榨干…… 1. 我叫王不留，地道東北人。 一個月前我還...
    沈念sama閱讀 51,414評論 3贊 390
  • 代替公主和親
    正文 我出身青樓，卻偏偏與公主長得像，于是被迫代替她去往敵國和親。 傳聞我的和親對象是個殘疾皇子，可洞房花燭夜當晚...
    茶點故事閱讀 47,750評論 2贊 370