你真的了解ThreadLocal吗?

一, 是什么?怎么用?

是什么?

是每个线程的本地变量,可以存储每个线程独有的变量.

怎么用?

可以为每个线程创建一个独有的变量对象

可以实现线程间的数据隔离

Spring声明式事务中使用ThreadLocal实现数据库隔离

---

二, 类架构

ThreadLocal属性

/** * 该值用于给ThreadLocalHashMap中存入值时线性探测插入的bucket位置 */ private final int threadLocalHashCode = nextHashCode(); /** * 下一个要给出的hashCode,每次原子性更新,从0开始 */ private static AtomicInteger nextHashCode = new AtomicInteger(); /** * hashCode增值,使用这个数字可以使key均匀的分布在2的幂次方的数组上 * 具体可以参考 https://www.javaspecialists.eu/archive/Issue164-Why-0x61c88647.html * 因为比较复杂,在这里不展开讨论 */ private static final int HASH_INCREMENT = 0x61c88647;

ThreadLocalMap属性

/** * Map的初始化容量 */ private static final int INITIAL_CAPACITY = 16; /** * 哈希表,长度始终是2的幂,原因在于2的幂-1的二进制全部为1 * 便于按位与操作 * 如16: 10000 - 1 = 1111 * 按位与后都会在数组中 */ private Entry[] table; /** * 哈希表的长度 */ private int size = 0; /** * 扩容阈值,默认为0,扩容大小为哈希表长度的2/3 */ private int threshold;

---

三, 实现原理

1, 为什么ThreadLocal可以实现线程隔离?

/** * 创建一个ThreadLocal,可以看出在构造器内部并没有处理任何事情 */ public ThreadLocal() {} /** * 给ThreadLocal中设置值会调用该方法 */ public void set(T value) { //获取当前线程 Thread t = Thread.currentThread(); //获取当前线程中的变量threadLocals ThreadLocalMap map = getMap(t); if (map != null) map.set(this, value); else //当前线程的threadLocals变量为空,创建map设置值 createMap(t, value); } ThreadLocalMap getMap(Thread t) { //获取t的线程变量 return t.threadLocals; }

由上可以看出给ThreadLocal设置值本质上是给Thread的本地变量threadLocals变量设置值,这就是为什么ThreadLocal可以实现线程之间数据隔离

---

2, 增删查操作

/** * 给ThreadLocal中设置值会调用该方法 */ public void set(T value) { //获取当前线程 Thread t = Thread.currentThread(); //获取当前线程中的变量threadLocals ThreadLocalMap map = getMap(t); if (map != null) map.set(this, value); else //当前线程的threadLocals变量为空,创建map设置值 createMap(t, value); } void createMap(Thread t, T firstValue) { //给线程设置变量值 t.threadLocals = new ThreadLocalMap(this, firstValue); } /** * 设置与key相关的值,key为ThreadLocal */ private void set(ThreadLocal<?> key, Object value) { Entry[] tab = table; int len = tab.length; //按位与获取插入的位置 int i = key.threadLocalHashCode & (len - 1); /** * 使用线性探测法插入值 * 从获取到的下标向后遍历,如果当前key等于数组中当前下标的key则直接修改值 * 如果数组当前下标位置为空则替换掉当前下标的entry */ for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) { ThreadLocal<?> k = e.get(); if (k == key) { e.value = value; return; } if (k == null) { //当前位置为空需要替换掉 replaceStaleEntry(key, value, i); return; } } //如果i向后没有与其相同的key或者为空的位置则直接替换掉当前位置的entry tab[i] = new Entry(key, value); int sz = ++size; //从i向后没有空位,并且数量大于阈值需要rehash,删除哈希表中某些为空的entry如果size大于阈值的3/4则需要扩容 if (!cleanSomeSlots(i, sz) && sz >= threshold) rehash(); } /** * 替换掉无效的entry */ private void replaceStaleEntry(ThreadLocal<?> key, Object value, int staleSlot) { Entry[] tab = table; int len = tab.length; Entry e; int slotToExpunge = staleSlot; for (int i = prevIndex(staleSlot, len); (e = tab[i]) != null; i = prevIndex(i, len)) //从后向前寻找空位,寻找到距离staleSlot最远的一个位置 if (e.get() == null) slotToExpunge = i; // 向后遍历 for (int i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) { ThreadLocal<?> k = e.get(); //找到了与ThreadLocal相同的key,替换值 if (k == key) { e.value = value; //替换掉当前位置的entry tab[i] = tab[staleSlot]; //交换entry tab[staleSlot] = e; // 前面没有空位,设置删除的位置 if (slotToExpunge == staleSlot) slotToExpunge = i; //删除后面为空的位置 cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); return; } if (k == null && slotToExpunge == staleSlot) slotToExpunge = i; } // 如果没有发现key,则直接替换 tab[staleSlot].value = null; tab[staleSlot] = new Entry(key, value); // staleSlot前有空位需要删除为空的entry if (slotToExpunge != staleSlot) cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); } /** * rehash哈希表 */ private void rehash() { //删除无效的entry并且rehash哈希表 expungeStaleEntries(); // 如果数量大于等于阈值的3/4,需要扩容 if (size >= threshold - threshold / 4) resize(); } /** * 删除无效的entry并且rehash哈希表 */ private void expungeStaleEntries() { Entry[] tab = table; int len = tab.length; for (int j = 0; j < len; j++) { Entry e = tab[j]; if (e != null && e.get() == null) expungeStaleEntry(j); } } /** * 双倍扩容之前的哈希表 */ 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) { //当前位置key为空,则直接GC ThreadLocal<?> k = e.get(); if (k == null) { e.value = null; // Help the GC } else { //获取新位置 int h = k.threadLocalHashCode & (newLen - 1); //从当前位置向后寻找一个为空的位置 while (newTab[h] != null) h = nextIndex(h, newLen); //重新插入entry newTab[h] = e; count++; } } } //重新设置阈值和哈希表属性 setThreshold(newLen); size = count; table = newTab; } /** * 删除某些entry以减半的方式删除 */ private boolean cleanSomeSlots(int i, int n) { 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); } //无条件右移1位 /2 } while ((n >>>= 1) != 0); return removed; } /** * 删除具体位置的entry,并且rehash之后的entry */ private int expungeStaleEntry(int staleSlot) { Entry[] tab = table; int len = tab.length; // 删除当前下标的entry tab[staleSlot].value = null; tab[staleSlot] = null; size--; Entry e; int i; //从当前位置向后遍历,寻找为空的或者rehash之后的entry for (i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) { ThreadLocal<?> k = e.get(); if (k == null) { e.value = null; tab[i] = null; size--; } else { int h = k.threadLocalHashCode & (len - 1); //rehash之后的位置不是当前的位置需要删除当前的entry if (h != i) { //help GC tab[i] = null; //从h向后遍历,寻找一个为空的位置 while (tab[h] != null) h = nextIndex(h, len); //插入entry tab[h] = e; } } } return i; } /** * 获取ThreadLocal中存放的值 */ public T get() { //1, 获取当前线程 Thread t = Thread.currentThread(); //2, 获取当前线程中的threadLocals变量,也就是ThreadLocalMap对象 ThreadLocalMap map = getMap(t); if (map != null) { //3, 获取之前设置的值并返回 ThreadLocalMap.Entry e = map.getEntry(this); if (e != null) { @SuppressWarnings("unchecked") T result = (T)e.value; return result; } } //3, 如果当前线程的threadLocals变量为空,则还没有初始化,需要进行初始化 return setInitialValue(); } /** * 设置初始化值 */ private T setInitialValue() { T value = initialValue(); Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null) map.set(this, value); else createMap(t, value); return value; } /** * 初始化值为null */ protected T initialValue() { return null; } /** * 删除变量 */ public void remove() { ThreadLocalMap m = getMap(Thread.currentThread()); if (m != null) m.remove(this); } /** * 删除某个entry */ private void remove(ThreadLocal<?> key) { Entry[] tab = table; int len = tab.length; int i = key.threadLocalHashCode & (len - 1); //从i向后遍历 for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) { if (e.get() == key) { //help GC e.clear(); //删除当前entry并且rehash后面的entry expungeStaleEntry(i); return; } } }

---

三, 存在问题

1, 内存泄漏问题

因为使用ThreadLocal本质上是使用ThreadLocalMap,在使用完ThreadLocal后,无法手动删除ThreadLocalMap中的key(ThreadLocal的引用),所以可能会引起内存泄漏问题,但是代码在设计的时候就考虑到了这一点,所以将ThreadLocalMap中的key(ThreadLocal)设置为了弱引用(WeakReference),即很容易被GC掉,但即便如此,我们还是要在使用完后调用ThreadLocal的remove方法,手动删除ThreadLocal引用,避免内存泄漏.

2, 子线程不能访问父线程变量

可以使用InheritableThreadLocal

原理

ThreadLocal<String> local = new InheritableThreadLocal<>(); local.set("main local variable"); public void set(T value) { //获取当前线程 Thread t = Thread.currentThread(); //因为InheritableThreadLocal重写了ThreadLocal的getMap方法,所以下面调用的为InheritableThreadLocal中的getMap,获取的为Thread类的inheritableThreadLocals变量 ThreadLocalMap map = getMap(t); if (map != null) map.set(this, value); else //当前线程的threadLocals变量为空,创建map设置值 createMap(t, value); } ThreadLocalMap getMap(Thread t) { return t.inheritableThreadLocals; } //创建子线程 Thread thread = new Thread(() -> { local.set("child thread variable"); System.out.println("child thread get local variable : " + local.get()); }); public Thread(Runnable target) { init(null, target, "Thread-" + nextThreadNum(), 0); } private void init(ThreadGroup g, Runnable target, String name, long stackSize) { init(g, target, name, stackSize, null, true); } private void init(ThreadGroup g, Runnable target, String name, long stackSize, AccessControlContext acc, boolean inheritThreadLocals) { //获取当前线程,这里为父线程,子线程还没有被创建出来 Thread parent = currentThread(); ... //这里的parent.inheritableThreadLocals在父线程set的时候已经初始化了 if (inheritThreadLocals && parent.inheritableThreadLocals != null) //所以子类的ThreadLocal也是使用的inheritableThreadLocals,不是之前的threadLocals this.inheritableThreadLocals = ThreadLocal.createInheritedMap(parent.inheritableThreadLocals); } static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) { return new ThreadLocalMap(parentMap); } private ThreadLocalMap(ThreadLocalMap parentMap) { Entry[] parentTable = parentMap.table; int len = parentTable.length; setThreshold(len); table = new Entry[len]; for (int j = 0; j < len; j++) { Entry e = parentTable[j]; if (e != null) { //向上转型 @SuppressWarnings("unchecked") ThreadLocal<Object> key = (ThreadLocal<Object>) e.get(); if (key != null) { //调用InheritableThreadLocal对象的childValue方法,返回e.value Object value = key.childValue(e.value); Entry c = new Entry(key, value); //插入到子线程的inheritableThreadLocals,也就是将父线程的inheritableThreadLocals数据复制到子线程中 int h = key.threadLocalHashCode & (len - 1); while (table[h] != null) h = nextIndex(h, len); table[h] = c; size++; } } } }

---