并发编程之 ThreadLocal

• 什么是ThreadLocal? 用来解决什么问题的?
• 说说你对ThreadLocal的理解
• ThreadLocal是如何实现线程隔离的?
• 为什么ThreadLocal会造成内存泄露? 如何解决
• 还有哪些使用ThreadLocal的应用场景?

一、ThreadLocal 介绍

1.1、ThreadLoacal 图示

1.2、ThreadLoacal 作用

实现线程安全的几种方式

• 互斥同步: synchronized 和 ReentrantLock
• 非阻塞同步: CAS, AtomicXXXX
• 无同步方案: 栈封闭，本地存储(Thread Local)

ThreadLocal 是一个将在多线程中为每一个线程创建单独的变量副本的类; 当使用ThreadLocal来维护变量时, ThreadLocal 会为每个线程创建单独的变量副本, 避免因多线程操作共享变量而导致的数据不一致的情况。

1.3、ThreadLoacal 的缺点

• ThreadLocal 容易造成内存泄露，用完需要手动 remove来避免
• ThreadLocal 不能在父子线程之间传递，需要使用 InheritableThreadLocal 实现

二、ThreadLoacal 的使用

//日志格式化，避免 SimpleDateFormat 多线程安全问题
public class DateUtils {
    public static final ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>(){
        @Override
        protected DateFormat initialValue() {
            return new SimpleDateFormat("yyyy-MM-dd");
        }
    };
}

三、ThreadLoacal 源码解析

3.1、Thread、ThreadLoacal、ThreadLocalMap的关系

• Thread 中持有 ThreadLocalMap 变量引用
• ThreadLoacal 用于操作 ThreadLocalMap
• ThreadLocalMap 是 ThreadLoacal 中的内部类

3.2、ThreadLoacal 初始化

//构造函数
public ThreadLocal() {
}
 public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
        return new SuppliedThreadLocal<>(supplier);
}
//设置初始化值
protected T initialValue() {
        return null;
}

3.3、ThreadLoacal 读取过程

• 获取值 ```java public T get() { //获取当前线程 Thread t = Thread.currentThread(); //获取当前线程的 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(); }

- 第一次获取，进行初始化
```java
private T setInitialValue() {
    //获取初始化的值
    T value = initialValue();
    //当前线程
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        //设置值
        map.set(this, value);
    else
        //创建ThreadLocalMap，并绑定到当前线程
        createMap(t, value);
    return value;
}

• 创建ThreadLocalMap，并绑定到当前线程

  // ThreadLocalMap 的key 是当前的 ThreadLoacal
  void createMap(Thread t, T firstValue) {
    //赋值给当前线程
    t.threadLocals = new ThreadLocalMap(this, firstValue);
  }

3.4、ThreadLoacal 写入过程

• 写入值

  public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        //添加值到ThreadLocalMap 中
        map.set(this, value);
    else
        //创建 ThreadLocalMap
        createMap(t, value);
  }

• 设置值到 ThreadLocalMap 中

  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;
    // 当前写入 哈希槽的下标索引
    //key.threadLocalHashCode 通过 AtomicInteger 递增
    int i = key.threadLocalHashCode & (len-1);
    for (Entry e = tab[i];
         e != null;
         //下一个元素 Entry，每次加一遍历
         e = tab[i = nextIndex(i, len)]) {
        //获取key 
        ThreadLocal<?> k = e.get();
        //对于多个线程，同一个ThreadLocal时
        //会执行替换值
        if (k == key) {
            e.value = value;
            return;
        }
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }
    //创建Entry，添加到哈希槽中
    tab[i] = new Entry(key, value);
    int sz = ++size;
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        //扩容
        rehash();
  }

3.5、ThreadLoacal 删除过程

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;
        }
    }
}

3.6、ThreadLoacal 扩容

private void rehash() {
    expungeStaleEntries();
    // Use lower threshold for doubling to avoid hysteresis
    //threshold 是 容量的 2/3
    if (size >= threshold - threshold / 4)
        resize();
}

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);
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                newTab[h] = e;
                count++;
            }
        }
    }
    //重写设置阀值
    setThreshold(newLen);
    size = count;
    table = newTab;
}

四、其它 ThreadLoacal 实现

• InheritableThreadLocal
  • 用于父子线程传递
  • 通过传递 ThreadLocalMap 实现
  • new Thread的时候init中，进行复制拷贝
• TransmittableThreadLocal

总结

• ThreadLocal 并不解决线程间共享数据的问题
• ThreadLocal 通过隐式的在不同线程内创建独立实例副本避免了实例线程安全的问题
• 每个线程持有一个 Map 并维护了 ThreadLocal 对象与具体实例的映射，该 Map 由于只被持有它的线程访问，故不存在线程安全以及锁的问题
• ThreadLocalMap 的 Entry 对 ThreadLocal 的引用为弱引用，避免了 ThreadLocal 对象无法被回收的问题
• ThreadLocalMap 的 set 方法通过调用 replaceStaleEntry 方法回收键为 null 的 Entry 对象的值（即为具体实例）以及 Entry 对象本身从而防止内存泄漏
• ThreadLocal 适用于变量在线程间隔离且在方法间共享的场景

参考

• https://pdai.tech/md/java/thread/java-thread-x-threadlocal.html
• https://github.com/alibaba/transmittable-thread-local
• https://www.cnblogs.com/aobing/p/13382184.html