FastThreadLocal源码

在Netty中，跟ThreadLocal做用很类似的类。配套使用的还有InternalThreadLocalMap，它对应ThreadLocalMap、FastThreadLocalThread，它对应Thread。对ThreadLocal不熟悉的小伙伴可以参考第三章 对象的共享中的对应部分。我们一起看下源码吧~

一、重要属性

　　1. 变量存放的位置

　　在Thread中，使用ThreadLocalMap的Entry[]来保存变量的副本。类似的，在FastThreadLocalThread中，使用InternalThreadLocalMap中的Object[]数组来保存副本：

class UnpaddedInternalThreadLocalMap {

    static final ThreadLocal<InternalThreadLocalMap> slowThreadLocalMap = new ThreadLocal<InternalThreadLocalMap>();
    static final AtomicInteger nextIndex = new AtomicInteger();


    /**
     * Used by {@link FastThreadLocal}
     */
    //存放缓存数据的数组，不同的FastThreadLocal存放在不同的下标
    Object[] indexedVariables;
    ...
}

　　UnpaddedInternalThreadLocalMap是InternalThreadLocalMap的父类。

　　2. variablesToRemoveIndex常量

　　在FastThreadLocal中有一项属性：

private static final int variablesToRemoveIndex = InternalThreadLocalMap.nextVariableIndex();

　　这个变量代表一个下标。ThreadLocalMap中Entry是一个指向ThreadLocal的弱引用，而在InternalThreadLocalMap中，在哪里维护FastThreadLocal的呢？

　　答案就是上面讲的indexedVariables数组中，下标为variablesToRemoveIndex的位置，这个下标始终为0。看下取值的方法InternalThreadLocalMap#nextVariableIndex：

public static int nextVariableIndex() {
    int index = nextIndex.getAndIncrement();
    if (index < 0) {
        nextIndex.decrementAndGet();
        throw new IllegalStateException("too many thread-local indexed variables");
    }
    return index;
}

　　因为variablesToRemoveIndex是类常量，在类加载期间就会初始化，所以此时取值为0。至于存储FastThreadLocal的结构下面会讲

　　3. index变量

private final int index;

　　每个FastThreadLocal都有一个属性，初始化时赋值，代表的是这个FastThreadLocal变量对应的副本在indexedVariables数组中存放的位置。

二、重要方法

　　1. 初始化方法

public FastThreadLocal() {
    //实例化阶段赋值，在整个过程中会实例化多次。从1开始递增
    index = InternalThreadLocalMap.nextVariableIndex();
}

　　整个Netty中用到了多个FastThreadLocal变量，而他们是共用一个计数器的，因为实例初始化方法在类加载之后，所以这里从1开始计数。并且每次递增1。

　　在ThreadLocalMap中计算存放下表的方法是 int i = key.threadLocalHashCode & (len-1); ，前半部分并不是真正计算哈希值，而是类似这里，使用一个计数器，每次递增，但不是递增1，而是递增0x61c88647，这么设置是为了降低哈希冲突。后半部分是对数组长度取模（对2的整数幂取模的简化方法）才能得到存放的下标，取模就意味着存在哈希冲突的问题，而在InternalThreadLocalMap中不存在哈希冲突。

　　2. set方法

public final void set(V value) {
    if (value != InternalThreadLocalMap.UNSET) {
        //从当前线程中获取存储变量的map
        InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.get();
        setKnownNotUnset(threadLocalMap, value);
    } else {
        remove();
    }
}

public static InternalThreadLocalMap get() {
    Thread thread = Thread.currentThread();
    if (thread instanceof FastThreadLocalThread) {
        return fastGet((FastThreadLocalThread) thread);
    } else {
        return slowGet();
    }
}


private static InternalThreadLocalMap fastGet(FastThreadLocalThread thread) {
    InternalThreadLocalMap threadLocalMap = thread.threadLocalMap();
    if (threadLocalMap == null) {
        thread.setThreadLocalMap(threadLocalMap = new InternalThreadLocalMap());
    }
    return threadLocalMap;
}

　　行2， public static final Object UNSET = new Object(); ，这个常量是用来填充的indexedVariables数组空白部分的。

　　行4，这个是从当前线程（FastThreadLocalThread）的threadLocalMap属性中拿到InternalThreadLocalMap。

　　我们看下行5的 setKnownNotUnset 方法：

private void setKnownNotUnset(InternalThreadLocalMap threadLocalMap, V value) {
    //这个index在实例化时赋值
    if (threadLocalMap.setIndexedVariable(index, value)) {
        //维护一个key的集合，当每次新增时，将key塞进入。更新时不用，因为key没变
        addToVariablesToRemove(threadLocalMap, this);
    }
}

public boolean setIndexedVariable(int index, Object value) {
    Object[] lookup = indexedVariables;
    if (index < lookup.length) {
        Object oldValue = lookup[index];
        lookup[index] = value;
        return oldValue == UNSET;
    } else {
        //原数组不够，会扩容
        expandIndexedVariableTableAndSet(index, value);
        return true;
    }
}


private static void addToVariablesToRemove(InternalThreadLocalMap threadLocalMap, FastThreadLocal<?> variable) {
    //根据指定下标，拿出维护的key集合
    Object v = threadLocalMap.indexedVariable(variablesToRemoveIndex);
    Set<FastThreadLocal<?>> variablesToRemove;
    if (v == InternalThreadLocalMap.UNSET || v == null) {
        //如果不存在，新建
        variablesToRemove = Collections.newSetFromMap(new IdentityHashMap<FastThreadLocal<?>, Boolean>());
        //塞到指定下标
        threadLocalMap.setIndexedVariable(variablesToRemoveIndex, variablesToRemove);
    } else {
        //如果存在，强转
        variablesToRemove = (Set<FastThreadLocal<?>>) v;
    }
    //将新key添加进去
    variablesToRemove.add(variable);
}

　　这个方法做了两件事，一是将副本存放到数组对应位置，如果下标越界会自动扩容。二是将FastThreadLocal存放到数组下标为0的位置，存放的结构是一个Set。

　　3. get方法

public final V get() {
    //从当前线程中取出map
    InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.get();
    //从对应位置找到副本
    Object v = threadLocalMap.indexedVariable(index);
    //不是默认值就返回
    if (v != InternalThreadLocalMap.UNSET) {
        return (V) v;
    }
    //如果是默认值，这里会进行一个set(null)的操作
    return initialize(threadLocalMap);
}

private V initialize(InternalThreadLocalMap threadLocalMap) {
    V v = null;
    try {
        //默认是null，protected级别，可以自定义实现
        v = initialValue();
    } catch (Exception e) {
        PlatformDependent.throwException(e);
    }
    //在数组对应位置设置v
    threadLocalMap.setIndexedVariable(index, v);
    //将key添加到集合
    addToVariablesToRemove(threadLocalMap, this);
    return v;
}

　　有意思的一点是，如果取出的是默认值UNSET，代表这个FastThreadLocal对应的副本还未设置过，此时会自动设置为null。

　　4. remove方法

public final void remove(InternalThreadLocalMap threadLocalMap) {
    if (threadLocalMap == null) {
        return;
    }
    //从数组中移除对应下标的元素，其实是用UNSET覆盖
    Object v = threadLocalMap.removeIndexedVariable(index);
    //从key集合中移除对应的key
    removeFromVariablesToRemove(threadLocalMap, this);

    if (v != InternalThreadLocalMap.UNSET) {
        try {
            //这个方法是一个空实现，可以继承然后自定义一些后续操作
            onRemoval((V) v);
        } catch (Exception e) {
            PlatformDependent.throwException(e);
        }
    }
}

public Object removeIndexedVariable(int index) {
    Object[] lookup = indexedVariables;
    if (index < lookup.length) {
        Object v = lookup[index];
        //将对应位置设置为默认值
        lookup[index] = UNSET;
        return v;
    } else {
        return UNSET;
    }
}

private static void removeFromVariablesToRemove(
        InternalThreadLocalMap threadLocalMap, FastThreadLocal<?> variable) {
    //取出key的集合
    Object v = threadLocalMap.indexedVariable(variablesToRemoveIndex);

    if (v == InternalThreadLocalMap.UNSET || v == null) {
        return;
    }

    @SuppressWarnings("unchecked")
    Set<FastThreadLocal<?>> variablesToRemove = (Set<FastThreadLocal<?>>) v;
    //从集合中删除key
    variablesToRemove.remove(variable);
}

三、总结

　　总体上讲，和ThreadLocal还是很类似的，区别是不存在不易察觉的弱引用导致的内存泄露问题，当然也需要手动remove。不存在哈希冲突的问题，存放key的方式也不一样。

参考：

吃透Netty源码系列二十六之FastThreadLocal二