ThreadLocal数据存储结构原理解析-Java开发

这篇文章主要为大家介绍了ThreadLocal数据存储结构原理解析，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪

一：简述

我们很多时候为了实现数据在线程级别下的隔离，会使用到ThreadLocal，那么TheadLocal是如何实现数据隔离的呢？今天就和大家一起分析一下ThreadLocal的实现原理。

二：TheadLocal的原理分析

1.ThreadLocal的存储结构

每个Thread对象中都有一个threadLocals成员变量，threadLocals是一个类型为ThreadLocalMap的map，而ThreadLocal正是基于这个map来实现线程级别的数据隔离的。

我们先看ThreadLocalMap的成员变量

        //默认的初始化容量大小
        private static final int INITIAL_CAPACITY = 16;
        //Entry数组 真正存储的数据结构
        private Entry[] table;
        //记录当前元素的数量
        private int size = 0;
        //扩容的阈值
        private int threshold;

Entry数组是真正存储数据的地方，可以看出Entry是一个key-value的存储结构，以当前ThreadLocal对象的引用作为key，存储的值为value。Entry继承了WeakReference，并且在构造函数的时候，调用super(k)（也就是WeakReference的构造函数）来对key进行初始化，所以Entry的key是一个弱引用。

static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;
            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
}

根据上面的分析，我们可以知道ThreadLocal的存储结构大概是这样的：

2.源码分析

接下来我们从ThreadLocal的set()，get(),remove()方法为入口对ThreadLocal的源码进行分析。

set()方法

首先判断当前线程的threadLocals是否初始化，如果没有初始化，那么调用createMap()方法进行初始化并设置值，否则调用ThreadLocalMap的set()方法设置值。

流程图：

三：源码分析

public void set(T value) {
         //利用当前线程获取它的threadLocals（threadLocals是一个ThreadLocalMap）
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        //如果已经初始化 那么就调用ThreadLocalMap的set()方法
        if (map != null)
            map.set(this, value);
        else
            // 没有初始化 先进行初始化
            createMap(t, value);
    }

    ThreadLocalMap getMap(Thread t) {
        //返回当前线程的threadLocals
        return t.threadLocals;
    }

createMap()

createMap()会调用ThreadLocalMap的构造函数对当前线程的threadLocals初始化，并且初始化Entry数组，然后利用hash算法计算出数组下标，将需要set的值存储在Entry数组。

    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

        ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            // 初始化Entry数组
            table = new Entry[INITIAL_CAPACITY];
            //计算数组下标
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            //设置默认的扩容阈值 和默认容量一样
            setThreshold(INITIAL_CAPACITY);
        }

如果threadLocals已经初始化，直接调用ThreadLocalMap的set()，接下来看ThreadLocalMap的set()方法。

首先利用hash算法计算数组下标，如果计算出的位置没有值，直接将值设置进去，如果存在值（出现hash冲突），分为三种情况：

1.如果key相同，那么直接覆盖值

2.如果计算出的位置的Entry的key为null，那么说明是无效的数据（key为null，entry不为null）,为了避免内存泄漏需要清除这种数据。所以调用replaceStaleEntry()方法将无效数据清除并且将需要设置的值设置到Entry数组中。

3.如果key不相同，而且计算出的位置的Entry的key不为null，那么进入到下一次for循环将计算出的下标+1，（如果到达下标最大值，则设置为0），利用新的位置重新进行判断，直到获取到一个合法的位置（线性寻址法解决hash冲突的问题）。

注：这里大家可以评论区讨论下为什么不和HashMap那样利用链表法解决hash冲突。我个人的看法是因为ThreadLocal的数据量不会向HashMap那么多，所以不需要利用链表和红黑树来解决hash冲突，链表法解决代码相对比较复杂而且扩容迁移数据的数据会比较麻烦。

源码：

private void set(ThreadLocal<?> key, Object value) {
            // We don't use a fast path as with get() because it is at
            // least as common to use set() to create new entries as
            // it is to replace existing ones, in which case, a fast
            // path would fail more often than not.
            Entry[] tab = table;
            int len = tab.length;
            // 计算数组下标
            int i = key.threadLocalHashCode & (len-1);
            //如果出现hash冲突会进入for循环
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();
                //如果key相同 那么直接将值覆盖
                if (k == key) {
                    e.value = value;
                    return;
                }
                //如果key为null 那么说明是无效的数据 需要进行清除
                if (k == null) {
                    //调用replaceStaleEntry()方法进行清除数据 并设置值
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }
            //如果没有hash冲突 直接赋值到对应下标的位置
            tab[i] = new Entry(key, value);
            // 将当前元素个数+1
            int sz = ++size;
            //如果没有需要清除的元素，并且当前元素个数已经达到扩容的阈值，那么进行扩容
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

接下来看replaceStaleEntry()，看ThreadLocal是如何清除无效的数据的。

当前节点是无效的数据，那么周围也可能存在无效的数据，所以ThreadLocal在清除无效的数据时，会顺便清除周围的连续的无效数据，先利用for循环从当前节点向前遍历，调整slotToExpunge的值（slotToExpunge 用于保存开始清除无效数据的下标位置），然后向后遍历，如果有entry的key和需要存放的数据的key相同，那么直接覆盖值，并且交换当前节点和新设置的entry的值。

流程图：

private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                                       int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;
            Entry e;
	    // slotToExpunge 用于保存开始清除无效数据的下标位置
            int slotToExpunge = staleSlot;
	    //从当前位置向前遍历，直到找到一个有效数据的下标
            for (int i = prevIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = prevIndex(i, len))
		//e.get()返回Entry的key，威null代表是无效数据 
                //（因为只有entry不为null才会进入for循环） 所以key为null，就是无效数据
                //for循环将清除无效数据的下标往前挪
                if (e.get() == null)
                    slotToExpunge = i;
            //从当前位置往后遍历
            for (int i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {
                ThreadLocal<?> k = e.get();
                //如果遍历的是否发现有和当前Entry相同的key的entry，那么交换两者的位置
                if (k == key) {
                    e.value = value;
                    tab[i] = tab[staleSlot];
                    tab[staleSlot] = e;
                    //如果slotToExpunge和staleSlot相等 
                    //证明当前节点的前面没有和当前节点连续的无效数据 
                    //所以从交换完的位置开始清除无效数据 调用cleanSomeSlots()方法和expungeStaleEntry()方法清除无效数据 清除完返回。
                    if (slotToExpunge == staleSlot)
                        slotToExpunge = i;
                    cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
                    return;
                }
                //如果key为null 而且当前entry之前没有与当前节点连续的无效数据
                //刷新开始清除无效数据的下标
                if (k == null && slotToExpunge == staleSlot)
                    slotToExpunge = i;
            }
            // If key not found, put new entry in stale slot
            //如果没有找到连续的无效数据 把当前的节点的value重置为null 并且将新的值赋值到当前位置
            //因为当前的entry是无效的数据 
            tab[staleSlot].value = null;
            tab[staleSlot] = new Entry(key, value);
            // If there are any other stale entries in run, expunge them
            //如果slotToExpunge 和 staleSlot不相等 说明有连续的无效数据需要顺便清除
            if (slotToExpunge != staleSlot)
                cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
        }

注：大家可以在评论区讨论一下，这里为什么要交换一下数据，我个人认为，第一是为了保证数据存储的位置尽可能的在hash计算出位置，有利于后续的get()方法，第二：交换位置之后有利于让无效的数据连续起来，提高清除无效数据的效率。

真正清除无效数据的方法是expungeStaleEntry()方法和cleanSomeSlots()方法

我们先看expungeStaleEntry()方法

expungeStaleEntry()

expungeStaleEntry()方法从当前节点开始向后遍历（直到遇到enrty为null的节点），将无效数据清除，并且重新计算有效的entry的数组下标，如果计算出的下标和entry的下标不相同（这是因为采用了线性寻址法，所以hash计算出下标可能和实际的下标不一样），重新找到合适的位置。

private int expungeStaleEntry(int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;
            // expunge entry at staleSlot
            //先将当前节点清除
            tab[staleSlot].value = null;
            tab[staleSlot] = null;
            size--;
            // Rehash until we encounter null
            Entry e;
            int i;
            for (i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {
                ThreadLocal<?> k = e.get();
                if (k == null) {
                    //key为null 证明是无效数据 清除
                    e.value = null;
                    tab[i] = null;
                    size--;
                } else {
                    //重新计算数组下标 如果数组下标发生变化 那么将数据迁移到新的位置上
                    int h = k.threadLocalHashCode & (len - 1);
                    if (h != i) {
                        tab[i] = null;
                        //重新利用线性寻址法寻找合适的下标位置
                        while (tab[h] != null)
                            h = nextIndex(h, len);
                        tab[h] = e;
                    }
                }
            }
            return i;
        }

然后是cleanSomeSlots()方法

cleanSomeSlots()

调用log(n)次expungeStaleEntry()方法进行清除无效数据。这个官方说不调用n次来清除，为了效率，而且经过测试调用log(n)次清除无效的数据的效果已经很好了。(n代表entry数组的长度)。

private boolean cleanSomeSlots(int i, int n) {
            //removed 是否清除了数据的标记
            boolean removed = false;
            Entry[] tab = table;
            int len = tab.length;
            do {
                i = nextIndex(i, len);
                Entry e = tab[i];
                if (e != null && e.get() == null) {
                    n = len;
                    removed = true;
                    i = expungeStaleEntry(i);
                }
            } while ( (n >>>= 1) != 0);
            return removed;
        }

如果set()方法设置值之后，需要扩容会调用rehash()方法进行扩容。

先调用expungeStaleEntries()清除一下数据，如果还是需要扩容，那么调用resize()进行扩容。

rehash()

       private void rehash() {
            //再试清除一下数据
            expungeStaleEntries();
            // Use lower threshold for doubling to avoid hysteresis
            //如果还是需要扩容 那么会调用 resize()进行扩容
            if (size >= threshold - threshold / 4)
                resize();
        }

resize()

resize()方法会创建一个容量为原来两倍的数组，并且将数据迁移到新的数组上面，将新的数组赋值给table变量。（扩容方法比较简单）

        private void resize() {
            Entry[] oldTab = table;
            int oldLen = oldTab.length;
            int newLen = oldLen * 2;
            Entry[] newTab = new Entry[newLen];
            int count = 0;
            for (int j = 0; j < oldLen; ++j) {
                Entry e = oldTab[j];
                if (e != null) {
                    ThreadLocal<?> k = e.get();
                    if (k == null) {
                        e.value = null; // Help the GC
                    } else {
                        int h = k.threadLocalHashCode & (newLen - 1);
                        //线性寻址法解决hash冲突
                        while (newTab[h] != null)
                            h = nextIndex(h, newLen);
                        newTab[h] = e;
                        count++;
                    }
                }
            }
            setThreshold(newLen);
            size = count;
            table = newTab;
        }

get()方法

获取到当前线程的threadLocals，如果threadLocals已经初始化，那么调用getEntry()方法获取值。否则调用setInitialValue()获取我们在initialValue()设置的初始化的值。

public T get() {
        Thread t = Thread.currentThread();
        //利用当前线程获取它的threadLocals（threadLocals是一个ThreadLocalMap）
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

现在我们看getEntry()方法

如果找到key相同的Entry 直接返回，否则调用getEntryAfterMiss()方法

getEntry()

private Entry getEntry(ThreadLocal<?> key) {
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            //如果找到key相同的Entry 直接返回
            if (e != null && e.get() == key)
                return e;
            else
                return getEntryAfterMiss(key, i, e);
        }

getEntryAfterMiss()

getEntryAfterMiss()从当前节点往后遍历查找，遍历找到key相同的entry，找到就返回，否则返回null，如果有无效数据，顺便清除一下。

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
            Entry[] tab = table;
            int len = tab.length;
            while (e != null) {
                ThreadLocal<?> k = e.get();
                //找到key相同的entry 直接返回
                if (k == key)
                    return e;
                if (k == null)
                    //当前数据为无效数据 清除一下
                    expungeStaleEntry(i);
                else
                    //否则向后继续查找
                    i = nextIndex(i, len);
                e = tab[i];
            }
            return null;
}

最后是remove()方法

remove()

利用hash算法计算下标，从下标位置开始往后遍历，找到key相同的entry，将entry删除，顺便调用expungeStaleEntry()方法清除一下无效的数据。

public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

private void remove(ThreadLocal<?> key) {
            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                if (e.get() == key) {
                    e.clear();
                    expungeStaleEntry(i);
                    return;
                }
            }
        }