netty源码阅读之性能优化工具类之FastThreadLocal的get方法实现

偏执的太偏执、 2022-05-09 11:34 166阅读 0赞

FastThreadLocal的get方法实现我们通过以下三部分分析：

1、获取ThreadLocalMap

2、直接通过索引找到对象

3、如果对象为空，那就初始化对象

我们从FastThreadLocal的get方法进入：

/**
         * Returns the current value for the current thread
         */
        public final V get() {
            return get(InternalThreadLocalMap.get());
        }

### 一、获取ThreadLocalMap ###

InternalThreadLocalMap.get()就是我么这个过程，查看源码：

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

这里又fastGet和slowGet，slowGet就是线程不为FastThreadLocalThread的时候，我们先看slowGet方法的实现：

private static InternalThreadLocalMap slowGet() {
            ThreadLocal<InternalThreadLocalMap> slowThreadLocalMap = UnpaddedInternalThreadLocalMap.slowThreadLocalMap;
            InternalThreadLocalMap ret = slowThreadLocalMap.get();
            if (ret == null) {
                ret = new InternalThreadLocalMap();
                slowThreadLocalMap.set(ret);
            }
            return ret;
        }

通过slowThreadLocalMap的get方法找出InternalThreadLocalMap，然后如果不存在就创建一个并放到slowThreadLocalMap里面，那么这个slowThreadLocalMap是什么的？

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

这个 slowThreadLocalMap是jdk原生的ThreadLocal里面的对象。

意思就是InternalThreadLocalMap是通过ThreadLocal的get方法里面把它取出来的，相对来说更加"slow"，那么fast呢？

看源码：

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

这一看我们就能知道它为什么fast了，因为它的InternalThreadLocalMap直接是这个thread的一个成员变量，直接取就可以。如果取不到就直接新建一个给它。

### 二、直接通过索引找到对象 ###

那么我们又回到了get方法，得到map之后，把map传进去get，看源码：

/**
         * Returns the current value for the specified thread local map.
         * The specified thread local map must be for the current thread.
         */
        @SuppressWarnings("unchecked")
        public final V get(InternalThreadLocalMap threadLocalMap) {
            Object v = threadLocalMap.indexedVariable(index);
            if (v != InternalThreadLocalMap.UNSET) {
                return (V) v;
            }
    
            return initialize(threadLocalMap);
        }

这段代码的意思是，从threadLocalMap里面取对象，如果取到的值不是UNSET那么就返回，否则就通过initialize方法初始化一个对象。

先看indexedVariable(index)方法吧：

public Object indexedVariable(int index) {
            Object[] lookup = indexedVariables;
            return index < lookup.length? lookup[index] : UNSET;
        }

就是在indexedVariables数组里面取出特定index的值。上一篇文章我们稍微提到了一个这个数组，这次我们分析一下。

这个数组是在这里初始化的：

UnpaddedInternalThreadLocalMap(Object[] indexedVariables) {
            this.indexedVariables = indexedVariables;
        }

然后到这里：

private InternalThreadLocalMap() {
            super(newIndexedVariableTable());
        }

然后newIndexedVariableTable：

private static Object[] newIndexedVariableTable() {
            Object[] array = new Object[32];
            Arrays.fill(array, UNSET);
            return array;
        }

这里很简单，就是创建一个初始化32的数组，数组里面的元素都是UNSET，这个UNSET是：

public static final Object UNSET = new Object();

注意这是一个静态的成员变量，所以在整个jvm进程里面，它都是不会变得。

**直接通过索引获取对象就是我们比jdk原生的更加“fast”的一个很重要的原因，另外一个更加“fast”的原因是在我们获取InternalThreadLocalMap 的时候，FastThreadLocalThread直接通过成员变量获取，当然更加快了。**

### 三、如果获取到的对象为UNSET，那就初始化对象 ###

从initialize(threadLocalMap)这里进入

private V initialize(InternalThreadLocalMap threadLocalMap) {
            V v = null;
            try {
                v = initialValue();
            } catch (Exception e) {
                PlatformDependent.throwException(e);
            }
    
            threadLocalMap.setIndexedVariable(index, v);
            addToVariablesToRemove(threadLocalMap, this);
            return v;
        }

看initialValue是什么：

/**
         * Returns the initial value for this thread-local variable.
         */
        protected V initialValue() throws Exception {
            return null;
        }

默认实现的方法是返回null，我们当然也可以覆盖这个方法去实现自己的逻辑，例如我们《[ netty源码阅读之性能优化工具类之FastThreadLocal的使用][netty_FastThreadLocal]》这篇文章里面initialValue的实现方法为：

private static FastThreadLocal<Object> threadLocal = new FastThreadLocal<Object>() {
            @Override
            protected Object initialValue() {
                return new Object();
            }
        };

然后有个threadLocalMap.setIndexedVariable(index, v);

/**
         * @return {@code true} if and only if a new thread-local variable has been created
         */
        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;
            }
        }

这里就是把我们初始化的值设置到map里面，下次我们要取得时候就能取到了。如果不够就扩容并且添加进去，如果旧值是UNSET就返回true。

最后还有一个addToVariablesToRemove(threadLocalMap, this);我们先通过名字记下来：

因为是初始化的值，所以以后是需要移除的。

[netty_FastThreadLocal]: https://blog.csdn.net/fst438060684/article/details/82956320