前言
保险出单场景中，业务员出单时后台需要根据业务员所在机构来决定业务流转，审计字段记录出单员信息等，这些在后端处理中需要多次用到，每笔订单都是独立对应一个业务线程，可以使用ThreadLocal将业务员代码存储到线程中，方便后续取值。
概述
我们知道想要启动一个新的线程，最终需要用到Thread类，一个Thread对应一个独立的线程。所以我们是不是可以在Thread中定义一个Map集合，最后以key-value的形式将内容存储到里面；我们在线程中想要拿到当前线程的引用对象，只需要调用Thread.currentThread()即可拿到实例，拿到实例后从其属性Map集合中进行取值即可，由于每个Thread都是独立的，这样就能做到线程间的隔离了。
ThreadLocal往Thread容器中添加数据时，以自身对象作为存储的key，以自身对象左右取值的Key;
正文
案例
public static void main(String[] args) { ThreadLocal<String > loginUserCode=new ThreadLocal<>(); new Thread(()->{ loginUserCode.set("100000"); System.out.println(Thread.currentThread().getName()+":"+loginUserCode.get()); }).start(); new Thread(()->{ System.out.println(Thread.currentThread().getName()+":"+loginUserCode.get()); loginUserCode.set("200000"); System.out.println(Thread.currentThread().getName()+":"+loginUserCode.get()); Thread thread = Thread.currentThread(); }).start(); }
通过上面的案例知道ThreadLocal的基本用法。
数据存储结构
从上述的步骤中我们知道，Thread中肯定存储一个缓存容器用于存储数据，所以先看下其缓存的实现
ThreadLocalMap的源码比较多，这里我就挑比较重点属性的出来讲解；
static class ThreadLocalMap { private Entry[] table; //默认Enrty[]容量 private static final int INITIAL_CAPACITY = 16; static class Entry extends WeakReference<ThreadLocal<?>> { /** The value associated with this ThreadLocal. */ Object value; Entry(ThreadLocal<?> k, Object v) { //将key值包装成弱引用进行存储 super(k); value = v; } } }
看过HashMap源码的同学看这部分应该会比较容易点，这里的Entry继承了弱引用修饰的ThreadLocal。
ThreadLocal: set(T value)方法
public void set(T value) { Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null) { map.set(this, value); } else { createMap(t, value); } }
ThreadLocalMap getMap(Thread t) { return t.threadLocals; }
void createMap(Thread t, T firstValue) { t.threadLocals = new ThreadLocalMap(this, firstValue); }
- 获取当前线程
- 从当前线程中获取缓存对象
- 判断该缓存对象是否被初始化，没有则创建一个容器并赋值
- 将当前的ThreadLocal对象作为key，与value存入缓存中
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 (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) { ThreadLocal<?> k = e.get(); //如果其k值对象一样，证明是修改操作，直接复制即可 if (k == key) { e.value = value; return; } //由于是弱引用，之前的key可能被垃圾回收，所以存储为null的，情况。 //所以这里需要重新选址和清理一些垃圾 if (k == null) { replaceStaleEntry(key, value, i); return; } } //走到这里，证明数组中不存在hash冲突的情况，这里创建一个对象并存入数组中 tab[i] = new Entry(key, value); //当前存储容量+1 int sz = ++size; //如果没有清理垃圾的情况发生，并且容量超过阈值大小了，需要进行扩容 if (!cleanSomeSlots(i, sz) && sz >= threshold) //扩容。容量为当前旧数组的2倍 rehash(); }
综上所述：
根据当前ThreadLocal计算Hash值，并进行与运算，得到数组下标
判断当前数组对应下标是否有值，没有则创建一个新的enrty对象进行存储，并尝试进行垃圾回收和扩容
如果数组对应下标已经有值了，则是hash冲突了，判断是否存在key值相等的情况，如果存在则直接覆盖
如果当前key值不相等，此时使用线性寻址法找出对应的下标位置
对key值为null的垃圾进行回收。
private void replaceStaleEntry(ThreadLocal<?> key, Object value, int staleSlot) { Entry[] tab = table; int len = tab.length; Entry e; // Back up to check for prior stale entry in current run. // We clean out whole runs at a time to avoid continual // incremental rehashing due to garbage collector freeing // up refs in bunches (i.e., whenever the collector runs). //存储当前下标志 int slotToExpunge = staleSlot; //往前找，找出被垃圾回收的ThreadLocal对应的下标值 for (int i = prevIndex(staleSlot, len); (e = tab[i]) != null; i = prevIndex(i, len)) if (e.get() == null) slotToExpunge = i; // Find either the key or trailing null slot of run, whichever // occurs first //在数组中一直往后寻找，看是否能找到key一致的位置 for (int i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) { ThreadLocal<?> k = e.get(); // If we find key, then we need to swap it // with the stale entry to maintain hash table order. // The newly stale slot, or any other stale slot // encountered above it, can then be sent to expungeStaleEntry // to remove or rehash all of the other entries in run. //找到位置，将该位置的值与之前ThreadLocal为null的位置进行互换 //这里主要让数据在数组中尽可能连城一块，减少碎片化 if (k == key) { e.value = value; //将当前key为null的位置与真正存储值的数据进行互换，减少碎片化 tab[i] = tab[staleSlot]; tab[staleSlot] = e; // Start expunge at preceding stale entry if it exists //判断在hash冲突位置的前面是否存在垃圾数据， //存在时 则两者不等，从最前面开始进行扫描清理垃圾 if (slotToExpunge == staleSlot) slotToExpunge = i; //垃圾清理 cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); return; } // If we didn't find stale entry on backward scan, the // first stale entry seen while scanning for key is the // first still present in the run. if (k == null && slotToExpunge == staleSlot) slotToExpunge = i; } // If key not found, put new entry in stale slot //如果key不存在，则创建一个新的，放入数组中 tab[staleSlot].value = null; tab[staleSlot] = new Entry(key, value); // If there are any other stale entries in run, expunge them //判断前面位置是否存在垃圾数据，存在则从最前面开始清理，否则不需要处理 if (slotToExpunge != staleSlot) cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); }
综上所述：
找出当前hash冲突位置前面是否存在key为null(被垃圾回收)的脏数据
一直往后找，看是否存在key相等的位置，有则将该位置的数据与hash冲突位置进行互换，减少内存空间的碎片化
垃圾清理，判断清理的位置是否在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; //一直往后找，找到位置为null的数组下标 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); //看是否存在Hash冲突的情况 if (h != i) { //将当前位置的值清理掉 //重新在hash冲突处往后寻找一个地址为null的数据进行存储 //因为前面可能存在清理过的位置，这样的好处是减少碎片化，将数据尽量往前面靠近 tab[i] = null; // Unlike Knuth 6.4 Algorithm R, we must scan until // null because multiple entries could have been stale. while (tab[h] != null) h = nextIndex(h, len); tab[h] = e; } } } return i; }
综上所述：
- 从参数下标处开始扫描，如果数组位置没有存储数据，则返回该下标
- 如果key已经被回收了，此时将该位置的空间进行清理
- 如果存在hash冲突的情况，将当前位置空间清理掉，重新在hash冲突处往后再寻找一个空的空间进行存储，这样的好处是让数据能连续，避免过度碎片化
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); } } while ( (n >>>= 1) != 0); return removed; }
由于整个可能存在碎片化过多的情况，而expungeStaleEntry()方法遇到位置为空时，就结束清理。所以需要配合cleanSomeSlots()方法进行指数次清理。我理解使用指数次清理的方法可能清理不是特别干净，但是相对整个数组的扫描效率要高得多，数组过大时，整组扫描清理的方法会过度消耗时间。
ThreadLocal:get()方法
public T get() { Thread t = Thread.currentThread(); 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(); }
- 获取当前线程
- 从当前线程中获取缓存对象
- 判断该缓存对象是否被初始化，没有则创建一个容器并赋默认值
- ThreadLocal对象作为key从缓存对象中获取值
private Entry getEntry(ThreadLocal<?> key) { int i = key.threadLocalHashCode & (table.length - 1); Entry e = table[i]; if (e != null && e.get() == key) return e; else return getEntryAfterMiss(key, i, e); }
ThreadLocal:remove()方法
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; } } }
总结
Thread中定义了ThreadLocalMap 容器用于存储当前线程数据，ThreadLocalMap 的数据结构采用数组的方法，不像HashMap采用数组+链表的方法，所以在产生hash冲突时，两者的处理方法不一样。ThreadLocalMap中Key为弱引用的ThreadLocal对象，当发生GC时，该对象会被清理，而此时key所对应的value为强引用，所以就存在key=null,value不为null的情况，如果线程持续时间长，value得不到回收就会存在内存泄漏，如果出现大量线程，可能还会引发内存溢出。
所以ThreadLocalMap中定义了一些回收策略，对key为null的垃圾进行清理后，可能会导致数组中存在大量不连续的null的空间，整个数组碎片化验证。所以在expungeStaleEntry()方法中，对垃圾清理的同时，也会有对应策略重新计算下标，将数组存储尽量连续性；
