ThreadLocal浅析

ThreadLocal用来存储线程隔离的数据。

Thread类中有一个ThreadLocalMap成员变量threadLocals,ThreadLocalMap中有一个ThreadLocal.ThreadLocalMap.Entry[16]数组table,用来存储该线程的ThreadLocal的存储的值。多个ThreadLocal在设置时通过ThreadLocal的成员变量threadLocalHashCode和数组大小-1与操作，得到存储的下标值。

ThreadLocal的常规用法：

ThreadLocal stringThreadLocal = new ThreadLocal<>(){
  @Override
  // 设置初始值
  protected String initialValue() {
    return "stringThreadLocal initialValue";
  }
};

ThreadLocal intThreadLocal = new ThreadLocal<>(){
  @Override
  protected Integer initialValue() {
    return 1;
  }
};

Thread t = new Thread(new Runnable() {
  @Override
  public void run() {
    stringThreadLocal.get();
    stringThreadLocal.set("set new value");
    // 使用完后最好进行移除，防止内存泄漏
    stringThreadLocal.remove();
  }
});

一个线程可以拥有多个ThreadLocal，用来存储多个不同的值，可以使用initialValue()方法进行初始化值。

ThreadLocal是如何保证线程隔离，存储数据的？

ThreaLocal类中有一个静态内部类ThreadLocal.ThreadLocalMap,而ThreadLocalMap中有一个静态内部类ThreadLocal.ThreadLocalMap.Entry，Entry中的成员变量Object value 用来存储ThreadLocal设置的值。

ThreadLocal的get方法

public T get() {
    // 获取当前线程
    Thread t = Thread.currentThread();
    // 当前线程作为key值，获取ThreadLocalMap
    ThreadLocal.ThreadLocalMap map = this.getMap(t);
    if (map != null) {
        // 通过getEntry方法传入当前的ThreadLocal变量，经过运算获取Entry的值
        ThreadLocal.ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            T result = e.value;
            return result;
        }
    }
    // 返回设置的初始值
    return this.setInitialValue();
}

ThreadLocal.ThreadLocalMap getMap(Thread t) {
  // 通过传入当前线程，获取线程的成员变量threadLocals
  return t.threadLocals;
}

// ThreadLocalMap中的getEntry方法
private ThreadLocal.ThreadLocalMap.Entry getEntry(ThreadLocal key) {
  // 计算Entry存储的下标
  int i = key.threadLocalHashCode & this.table.length - 1;
  // 通过ThreadLocal.ThreadLocalMap.Entry[] table 数组获取对应的Entry
  ThreadLocal.ThreadLocalMap.Entry e = this.table[i];
  return e != null && e.get() == key ? e : this.getEntryAfterMiss(key, i, e);
}

可用看到，通过Thread.currentThread()获取当前线程，通过当前线程作为键值，获取到ThreadLocalMap。而这个ThreadLocalMap就是线程中的成员变量threadLocals，这就与Thread对应起来了。再通过获取到的ThreadLocalMap通过getEntry()方法，传入当前的ThreadLocal获取ThreadLocal存储的值。

ThreadLocal的set()方法

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocal.ThreadLocalMap map = this.getMap(t);
    if (map != null) {
        map.set(this, value);
    } else {
        this.createMap(t, value);
    }

}

// ThreadLocalMap中的set方法
private void set(ThreadLocal key, Object value) {
  // 数组，用来存储对应的Entry
  ThreadLocal.ThreadLocalMap.Entry[] tab = this.table;
  int len = tab.length;
  // 通过threadLocalHashCode加上与操作，获取下标
  int i = key.threadLocalHashCode & len - 1;

  // 获取对应的ThreadLocal进行值的设置
  for(ThreadLocal.ThreadLocalMap.Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {
    ThreadLocal k = (ThreadLocal)e.get();
    if (k == key) {
      e.value = value;
      return;
    }

    if (k == null) {
      this.replaceStaleEntry(key, value, i);
      return;
    }
  }

  tab[i] = new ThreadLocal.ThreadLocalMap.Entry(key, value);
  int sz = ++this.size;
  if (!this.cleanSomeSlots(i, sz) && sz >= this.threshold) {
    this.rehash();
  }

}

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

ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
  this.table = new ThreadLocal.ThreadLocalMap.Entry[16];
  int i = firstKey.threadLocalHashCode & 15;
  this.table[i] = new ThreadLocal.ThreadLocalMap.Entry(firstKey, firstValue);
  this.size = 1;
  this.setThreshold(16);
}

可以看到，ThreadLocalMap中通过table来保存一个大小为16的ThreadLocal.ThreadLocalMap.Entry数组，而这个数组就是用来存储ThreadLocal.ThreadLocalMap.Entry的，也就是说多个ThreadLocal设置的值，通过这个数组来进行保存。

ThreadLocal的线程不安全

ThreadLocal在设置一个同一个对象的值时，可能存在线程不安全的问题。因为ThreadLocal存储的是栈中一个对象的引用，而对象是存储在堆中的，ThreadLocal对这个对象的引用指向的其实是堆中的同一个对象。所以一个线程对这个对象的值进行更改时，其它ThreadLocal在取值时也会被修改。

解决方法：1. 不要存储同一个对象。2. 使用initialValue()对每个TreadLocal进行赋值初始值。

Integer的valueOf方法：

public static Integer valueOf(int i) {
    return i >= -128 && i <= Integer.IntegerCache.high ? Integer.IntegerCache.cache[i + 128] : new Integer(i);
}

在这可以看到，如果对Integer的值进行加减操作，并且存储的值不是在-128~127之间的时候，会创建一个新的Integer对象。

ThreadLocal导致内存泄漏

ThreadLocal内存泄漏图解

使用ThreadLocal进行存取值时，传入的ThreadLocal作为键值时用弱引用包裹的，当发生GC时，如果ThreadLocal被GC回收掉了，那么这个key值就不存在了，而Thread中存储的ThreadLocal.ThreadLocalMap 是一个强引用，不会被GC回收，这种情况下，就会发生内存泄漏。只有当前thread结束以后, current thread就不会存在栈中,强引用断开, Current Thread, Map, value将全部被GC回收。

所以当ThreadLocal使用完成的时候，需要调用remove方法将value移除掉，这样就不会存在内存泄漏了。

key值为什么使用弱引用而不是强引用？

下面我们分两种情况讨论：

key 使用强引用：对 ThreadLocal 对象实例的引用被置为 null 了，但是 ThreadLocalMap 还持有这个 ThreadLocal 对象实例的强引用，如果没有手动删除， ThreadLocal 的对象实例不会被回收，导致 Entry 内存泄漏。

key 使用弱引用：对 ThreadLocal 对象实例的引用被被置为 null 了，由于 ThreadLocalMap 持有 ThreadLocal 的弱引用，即使没有手动删除，ThreadLocal 的对象实例也会被回收。value 在下一次 ThreadLocalMap 调用 set，get，remove 都有机会被回收。

比较两种情况，我们可以发现：由于 ThreadLocalMap 的生命周期跟 Thread 一样长，如果都没有手动删除对应 key，都会导致内存泄漏，但是使用弱引用可以多一层保障。

因此，ThreadLocal 内存泄漏的根源是：由于 ThreadLocalMap 的生命周期跟Thread 一样长，如果没有手动删除对应 key 就会导致内存泄漏，而不是因为弱引用。