ConcurrentHashMap源码剖析

前言

HashMap虽好，却不是线程安全的，需要自行进行同步；HashTable是最早出现的哈比表实现，其用synchronized修饰方法，实现了线程安全，效率也因此大打折扣；JUC中的ConcurrentHashMap是最为推荐的线程安全哈希表，有必要进行学习。

但同时需要注意不能因为其线程安全就忽视了线程安全，因为其方法虽然可视为原子操作，但如果调用的时候不原子也会白费，例如map.put(key, map.get(key) + 1)，这谁也救不了你。

public class LeetCode {
    static volatile int r = 2;
    
    public static void main(String[] args) throws Exception {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
		new Thread(() -> {
            for (int i = 0; i < 100000; i++) {
                map.put("1", map.getOrDefault("1", 0) + 1);
            }
            --r;
            ;
        }).start();
        new Thread(() -> {
            for (int i = 0; i < 100000; i++) {
                map.put("1", map.getOrDefault("1", 0) + 1);
            }
            --r;
        }).start();
        while (r != 0) Thread.yield();
        System.out.println(map.get("1"));
    }
}

继承与实现

public class ConcurrentHashMap<K,V> extends AbstractMap<K,V>
    implements ConcurrentMap<K,V>, Serializable {

ConcurrentHashMap相比于HashMap少了Cloneable，Map<k, v>换成了ConcurrentMap<k, v>，而ConcurrentMap<k, v>又继承了Map<k, v>。

然而方法并没有增多，只是重写了一些方法。比如getOrDefualt()，map允许key存在时即使value为null也算存在然后返回null；currentMap将不会判断contains(key)，若value为null直接返回defaultValue。

//Map
default V getOrDefault(Object key, V defaultValue) {
    V v;
    return (((v = get(key)) != null) || containsKey(key))
        ? v
        : defaultValue;
}

//ConcurentMap
@Override
default V getOrDefault(Object key, V defaultValue) {
    V v;
    return ((v = get(key)) != null) ? v : defaultValue;
}

变动主要是为并发服务，少抛了很多异常，相应地改成了continue或break。

Unsafe与AtomicInteger

想看懂ConcurrentHashMap，就必须知道Unsafe。

Unsafe类是JDK为了能直接操控内存和线程的而设计的类，Unsafe被广泛应用于java.nio和并发包等实现中。

一些有用的方法：

1. objectFieldOffset：能够获取到指定实例变量的在对象内存中的偏移量。
   long offset = UNSAFE.objectFieldOffset(UnsafeTest.class.getDeclaredField(“state”));
2. compareAndSwapInt：通过比较并替换的机制，修改指定偏移量内存的值。
   UNSAFE.compareAndSwapInt(unsafeTest, offset, 0, 1)
3. park：挂起某一线程
4. unpark：唤醒某一线程

AtomicInteger不必多介绍，因为它很简单又典型，故以它为例讲讲Unsafe如何使用。

以下为AtomicInteger所有的成员变量，其中valueOffset是偏移量，就是AtomicInteger对象的成员属性value相对于atomicInteger对象内存地址的偏移量。

private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;

static {
    try {
        valueOffset = unsafe.objectFieldOffset
            (AtomicInteger.class.getDeclaredField("value"));
    } catch (Exception ex) { throw new Error(ex); }
}

private volatile int value;

拿一个方法看AtomicInteger如何实现线程安全：

//AtomicInteger.addAndGet
public final int addAndGet(int delta) {
    return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
}

//unsafe.getAndAddInt
public final int getAndAddInt(Object o, long l, int i) {
    int oldValue;
    do {
        oldValue = this.getIntVolatile(o, l);
    } while(!this.compareAndSwapInt(o, l, oldValue, oldValue + i));
    return oldValue;
}

CAS，很典型的乐观锁，它会先获得值，然后再更改，更改的时候，如果oldValue与当前的值不同，则返回false，若相同则成功更改。

AQS

自己抄自己 Java 并发（AQS）
AbstractQueuedSynchronizer，抽象队列同步器，简称同步器。它是用来构建锁或者其他同步组件的基础框架。

剩余

太多