Ref:
https://mp.weixin.qq.com/s/8Ql-5kaUtxiCWyHR6uPPBw
https://www.cnblogs.com/fengzheng/p/8690253.html

1.使用场景

ThreadLocal 归纳下来就 2 类用途：

  • 保存线程上下文信息，在任意需要的地方可以获取。
  • 线程安全的，避免某些情况需要考虑线程安全必须同步带来的性能损失。

根据 ThreadLocal 的特性，一些场景：

  • 同一线程在某地方进行设置，在随后的任意地方都可以获取到（复杂业务场景中代替一些参数的显式传递），从而可以用来保存线程上下文信息。
  • 每个请求怎么把一串后续关联起来，就可以用 ThreadLocal 进行 set，在后续的任意需要记录日志的方法里面进行 get 获取到请求 id，从而把整个请求串起来。
  • Spring 的事务管理，用 ThreadLocal 存储 Connection，从而各个 DAO 可以获取同一 Connection，可以进行事务回滚，提交等操作。

    ThreadLocal 的这种用处，很多时候是用在一些优秀的框架里面的，一般我们很少接触，反而下面的场景我们接触的更多一些！

线程安全的，避免某些情况需要考虑线程安全必须同步带来的性能损失！

ThreadLocal 为解决多线程程序的并发问题提供了一种新的思路。但是 ThreadLocal 也有局限性，我们来看看阿里规范：
image.png
每个线程往 ThreadLocal 中读写数据是线程隔离，互相之间不会影响的，所以 ThreadLocal 无法解决共享对象的更新问题！

由于不需要共享信息，自然就不存在竞争问题了，从而保证了某些情况下线程的安全，以及避免了某些情况需要考虑线程安全必须同步带来的性能损失！！！

image.png

使用示例

  1. public class ThreadLocalTest {
  2.     private static ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
  4.     public static void main(String[] args) {
  6.         new Thread(() -> {
  7.             try {
  8.                 for (int i = 0; i < 100; i++) {
  9.                     // 设值
  10.                     threadLocal.set(i);
  11.                     System.out.println(Thread.currentThread().getName() + "====" + threadLocal.get());
  12.                     try {
  13.                         Thread.sleep(200);
  14.                     } catch (InterruptedException e) {
  15.                         e.printStackTrace();
  16.                     }
  17.                 }
  18.             } finally {
  19.                 threadLocal.remove();
  20.             }
  21.         }, "threadLocal1").start();
  24.         new Thread(() -> {
  25.             try {
  26.                 for (int i = 0; i < 100; i++) {
  27.                     System.out.println(Thread.currentThread().getName() + "====" + threadLocal.get());
  28.                     try {
  29.                         Thread.sleep(200);
  30.                     } catch (InterruptedException e) {
  31.                         e.printStackTrace();
  32.                     }
  33.                 }
  34.             } finally {
  35.                 threadLocal.remove();
  36.             }
  37.         }, "threadLocal2").start();
  38.     }
  39. }
  41. Output:
  42. ...
  43. threadLocal2====null
  44. threadLocal1====98
  45. threadLocal2====null
  46. threadLocal1====99

2.ThreadLocal 实现

Thread、ThreadLocalMap、ThreadLocal 总览图：
ThreadLocal - 图3
Thread 类有属性变量 threadLocals （类型是 ThreadLocal.ThreadLocalMap），也就是说每个线程有一个自己的 ThreadLocalMap ，所以每个线程往这个 ThreadLocal 中读写是隔离的，互相不会影响。
一个 ThreadLocal 只能存储一个 Object 对象，如果需要存储多个 Object 对象那么就需要多个 ThreadLocal。
如图：
ThreadLocal - 图4
看到上面的几个图，大概思路应该都清晰了，我们 Entry 的 key 指向 ThreadLocal 用虚线表示弱引用 ，下面我们来看看 ThreadLocalMap:

  1. public class ThreadLocal<T> {
  3.     public T get() {
  4.         Thread t = Thread.currentThread();
  5.         ThreadLocalMap map = getMap(t);
  6.         if (map != null) {
  7.             ThreadLocalMap.Entry e = map.getEntry(this);
  8.             if (e != null) {
  9.                 @SuppressWarnings("unchecked")
  10.                 T result = (T)e.value;
  11.                 return result;
  12.             }
  13.         }
  14.         return setInitialValue();
  15.     }
  17.     public void set(T value) {
  18.         Thread t = Thread.currentThread();
  19.         ThreadLocalMap map = getMap(t);
  20.         if (map != null)
  21.             map.set(this, value);
  22.         else
  23.             createMap(t, value);
  24.     }
  26.     public void remove() {
  27.          ThreadLocalMap m = getMap(Thread.currentThread());
  28.          if (m != null)
  29.              m.remove(this);
  30.      }
  32.     ThreadLocalMap getMap(Thread t) {
  33.         return t.threadLocals;
  34.     }
  36.     static class ThreadLocalMap {
  38.         private Entry[] table;
  40.         /**
  41.              * The entries in this hash map extend WeakReference, using
  42.              * its main ref field as the key (which is always a
  43.              * ThreadLocal object).  Note that null keys (i.e. entry.get()
  44.              * == null) mean that the key is no longer referenced, so the
  45.              * entry can be expunged from table.  Such entries are referred to
  46.              * as "stale entries" in the code that follows.
  47.              */
  48.         static class Entry extends WeakReference<ThreadLocal<?>> {
  49.             /** The value associated with this ThreadLocal. */
  50.             Object value;
  52.             Entry(ThreadLocal<?> k, Object v) {
  53.                 super(k);
  54.                 value = v;
  55.             }
  56.         }
  58.         private Entry getEntry(ThreadLocal<?> key) {
  59.             int i = key.threadLocalHashCode & (table.length - 1);
  60.             Entry e = table[i];
  61.             if (e != null && e.get() == key)
  62.                 return e;
  63.             else
  64.                 return getEntryAfterMiss(key, i, e);
  65.         }
  67.         /**
  68.          * Set the value associated with key.
  69.          *
  70.          * @param key the thread local object
  71.          * @param value the value to be set
  72.          */
  73.         private void set(ThreadLocal<?> key, Object value) {
  75.             // We don't use a fast path as with get() because it is at
  76.             // least as common to use set() to create new entries as
  77.             // it is to replace existing ones, in which case, a fast
  78.             // path would fail more often than not.
  80.             Entry[] tab = table;
  81.             int len = tab.length;
  82.             int i = key.threadLocalHashCode & (len-1);
  84.             for (Entry e = tab[i];
  85.                  e != null;
  86.                  e = tab[i = nextIndex(i, len)]) {
  87.                 ThreadLocal<?> k = e.get();
  89.                 if (k == key) {
  90.                     e.value = value;
  91.                     return;
  92.                 }
  94.                 if (k == null) {
  95.                     replaceStaleEntry(key, value, i);
  96.                     return;
  97.                 }
  98.             }
  100.             tab[i] = new Entry(key, value);
  101.             int sz = ++size;
  102.             if (!cleanSomeSlots(i, sz) && sz >= threshold)
  103.                 rehash();
  104.         }
  106.         /**
  107.          * Expunge a stale entry by rehashing any possibly colliding entries
  108.          * lying between staleSlot and the next null slot.  This also expunges
  109.          * any other stale entries encountered before the trailing null.  See
  110.          * Knuth, Section 6.4
  111.          *
  112.          * @param staleSlot index of slot known to have null key
  113.          * @return the index of the next null slot after staleSlot
  114.          * (all between staleSlot and this slot will have been checked
  115.          * for expunging).
  116.          */
  117.         private int expungeStaleEntry(int staleSlot) {
  118.             Entry[] tab = table;
  119.             int len = tab.length;
  121.             // expunge entry at staleSlot 
  122.             // 删除无用entry(key弱引用被回收 value尚存)
  123.             tab[staleSlot].value = null;
  124.             tab[staleSlot] = null;
  125.             size--;
  127.             // Rehash until we encounter null
  128.             Entry e;
  129.             int i;
  130.             for (i = nextIndex(staleSlot, len);
  131.                  (e = tab[i]) != null;
  132.                  i = nextIndex(i, len)) {
  133.                 ThreadLocal<?> k = e.get();
  134.                 if (k == null) {
  135.                     e.value = null;
  136.                     tab[i] = null;
  137.                     size--;
  138.                 } else {
  139.                     int h = k.threadLocalHashCode & (len - 1);
  140.                     if (h != i) {
  141.                         tab[i] = null;
  143.                         // Unlike Knuth 6.4 Algorithm R, we must scan until
  144.                         // null because multiple entries could have been stale.
  145.                         while (tab[h] != null)
  146.                             h = nextIndex(h, len);
  147.                         tab[h] = e;
  148.                     }
  149.                 }
  150.             }
  151.             return i;
  152.         }
  153.     }
  154. }

java 对象的引用包括 ： 强引用，软引用，弱引用，虚引用 。
因为这里涉及到弱引用，简单说明下：

  • 弱引用也是用来描述非必需对象的，当 JVM 进行垃圾回收时，无论内存是否充足，该对象仅仅被弱引用关联，那么就会被回收。

当仅仅只有 ThreadLocalMap 中的 Entry 的 key 指向 ThreadLocal 的时候，ThreadLocal 会进行回收的。
ThreadLocal 被垃圾回收后，在 ThreadLocalMap 里对应的 Entry 的键值会变成 null，但是 Entry 是强引用，那么 Entry 里面存储的 Object，并没有办法进行回收，所以 ThreadLocalMap 做了一些额外的回收工作。
ThreadLocal - 图5
虽然做了但是也会存在内存泄漏风险（最佳实践使用静态变量）。

3.实践

很多时候，我们都是用在线程池的场景，程序不停止，线程基本不会销毁

由于线程的生命周期很长，如果我们往 ThreadLocal 里面 set 了很大很大的 Object 对象，虽然 set、get 等方法在特定的条件会调用进行额外的清理，但是 ThreadLocal 被垃圾回收后，在 ThreadLocalMap 里对应的 Entry 的键值会变成 null，但后续无操作 set、get 等方法。

  • 应该在我们不使用的时候，主动调用 remove 方法进行清理。使用完 ThreadLocal ，手动调用 remove () 方法，例如 Tomcat 的 Session 例子，如果不在拦截器或过滤器中处理，不仅可能出现内存泄漏问题，而且会影响业务逻辑（在每次请求进来时先清理掉之前的 Session ，一般可以用拦截器、过滤器来实现）；
  • 把 ThreadLocal 定义为 static, 由于 ThreadLocal 有强引用在，那么在 ThreadLocalMap 里对应的 Entry 的键会永远存在，那么执行 remove 的时候就可以正确进行定位到并且删除。image.png

  • 最佳实践： ```java public class ContextHolder {

    private static final ThreadLocal CONTEXT_THREAD_LOCAL 

    1.     = ThreadLocal.withInitial(new Object());
    3. public static void clean() {
    4.     CONTEXT_THREAD_LOCAL.remove();

    } }

    try { // 其它业务逻辑 } finally { ContextHolder.clean(); } ```

    其他应用

    Netty 中有 FastThreadLocal, FastThreadLocal 的吞吐量优于 jdkThreadLocal.