并发编程之ThreadLocal深入理解

点赞再看，养成习惯，搜一搜【一角钱技术】关注更多原创技术文章。本文 GitHub org_hejianhui/JavaStudy 已收录，有我的系列文章。

前言

在日常的开发中，我们经常会遇到在当前运行线程中保存一些信息，并且各线程之间是隔离的，不会相互影响，不存在并发问题，通过这样的方式来实现请求调用链中方法之间参数传递的解耦，提升代码结构的稳定性等。Java ThreadLocal就是用于实现这一目标的。在学习之前我们先带着以下几个问题：

1. ThreadLocal 是什么?
2. ThreadLocal 怎么用?
3. ThreadLocal 和线程同步机制相比较？
4. ThreadLocal 是如何实现线程隔离的呢？
5. ThreadLocal 如何避免内存泄漏呢？
6. ThreadLocal 与 Thread、ThreadLocalMap 之间的关系？

以下分析均基于JDK1.8。

什么是ThreadLocal

ThreadLocal，很多地方叫做线程本地变量，也有些地方叫做线程本地存储。

ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量，这样同时多个线程访问该变量并不会彼此相互影响，因此他们使用的都是自己从内存中拷贝过来的变量的副本，这样就不存在线程安全问题，也不会影响程序的执行性能。

注意：虽然ThreadLocal能够解决上面说的问题，但是由于在每个线程中都创建了副本，所以要考虑它对资源的消耗，比如内存的占用会比不使用ThreadLocal要大。

ThreadLocal 怎么用

通常使用静态的变量来维护ThreadLocal，如:

static ThreadLocal sThreadLocal = new ThreadLocal

会自动在每一个线程上创建一个 T 的副本，副本之间彼此独立，互不影响，可以用 ThreadLocal 存储一些参数，以便在线程中多个方法中使用，用以代替方法传参的做法。

通过一个例子来了解 ThreadLocal：

package com.niuh.threadlocal;

/**
 * 

 * ThreadLocal 示例
 * 
 */
public class ThreadLocalDemo {
    /**
     * ThreadLocal变量，每个线程都有一个副本，互不干扰
     */
    public static final ThreadLocal THREAD_LOCAL = new ThreadLocal<>();

    public static void main(String[] args) throws Exception {
        new ThreadLocalDemo().threadLocalTest();
    }

    public void threadLocalTest() throws Exception {
        // 主线程设置值
        THREAD_LOCAL.set("一角钱技术");
        String v = THREAD_LOCAL.get();
        System.out.println("Thread-0线程执行之前，" + Thread.currentThread().getName() + "线程取到的值：" + v);

        new Thread(new Runnable() {
            @Override
            public void run() {
                String v = THREAD_LOCAL.get();
                System.out.println(Thread.currentThread().getName() + "线程取到的值：" + v);
                // 设置 threadLocal
                THREAD_LOCAL.set("一角钱技术2020");
                v = THREAD_LOCAL.get();
                System.out.println("重新设置之后，" + Thread.currentThread().getName() + "线程取到的值为：" + v);
                System.out.println(Thread.currentThread().getName() + "线程执行结束");
            }
        }).start();
        // 等待所有线程执行结束
        Thread.sleep(3000L);
        v = THREAD_LOCAL.get();
        System.out.println("Thread-0线程执行之后，" + Thread.currentThread().getName() + "线程取到的值：" + v);
    }
}

首先通过 static final 定义了一个 THREAD_LOCAL 变量，其中 static 是为了确保全局只有一个保存 String 对象的 ThreadLocal 实例；final 确保 ThreadLocal 的实例不可更改，防止被意外改变，导致放入的值和取出来的不一致，另外还能防止 ThreadLocal 的内存泄漏。上面的例子是演示在不同的线程中获取它会得到不同的结果，运行结果如下：

Thread-0线程执行之前，main线程取到的值：一角钱技术
Thread-0线程取到的值：null
重新设置之后，Thread-0线程取到的值为：一角钱技术2020
Thread-0线程执行结束
Thread-0线程执行之后，main线程取到的值：一角钱技术

• 首先在 Thread-0 线程执行之前，先给 THREAD_LOCAL 设置为 一角钱技术，然后可以取到这个值；
• 然后通过创建一个新的线程以后去取这个值，发现新线程取到的为 null，意味着这个变量在不同线程中取到的值是不同的，不同线程之间对于 ThreadLocal 会有对应的副本；
• 接着在线程 Thread-0 中执行对 THREAD_LOCAL 的修改，将值改为 一角钱技术2020，可以发现线程 Thread-0 获取的值变为了 一角钱技术2020，主线程依然会读取到属于它的副本数据 一角钱技术，这就是线程的封闭。

看到这里，我相信大家一定会好奇 ThreadLocal 是如何做到多个线程对同一对象 set 操作，但是 get 获取的值还都是每个线程 set 的值呢。

ThreadLocal和线程同步机制相比较

ThreadLocal和线程同步机制都是为了解决多线程中相同变量的访问冲突问题。

在同步机制中，通过对象的锁机制保证同一时间只有一个线程访问变量。这时该变量是多个线程共享的，使用同步机制要求程序慎密地分析什么时候对变量进行读写，什么时候需要锁定某个对象，什么时候释放对象锁等繁杂的问题，程序设计和编写难度相对较大。

而ThreadLocal则从另一个角度来解决多线程的并发访问。ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。因为每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的变量封装进ThreadLocal。

总的来说，对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。

ThreadLocal源码解析

成员变量

// 当前 ThreadLocal 的 hashCode，由 nextHashCode() 计算而来
// 用于计算当前 ThreadLocal 在 ThreadLocalMap 中的索引位置
private final int threadLocalHashCode = nextHashCode();
// 哈希魔数，主要与斐波那契散列法以及黄金分割有关
private static final int HASH_INCREMENT = 0x61c88647;
// 返回计算出的下一个哈希值，其值为 i * HASH_INCREMENT，其中 i 代表调用次数
private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}
// 保证了在一台机器中每个 ThreadLocal 的 threadLocalHashCode 是唯一的
private static AtomicInteger nextHashCode = new AtomicInteger();

其中的 HASH_INCREMENT 也不是随便取的，它转化为十进制是 1640531527，2654435769 转换成 int 类型就是 -1640531527，2654435769 等于 (√5-1)/2 乘以 2 的 32 次方。(√5-1)/2 就是黄金分割数，近似为 0.618，也就是说 0x61c88647 理解为一个黄金分割数乘以 2 的 32 次方，它可以保证 nextHashCode 生成的哈希值，均匀的分布在 2 的幂次方上，且小于 2 的 32 次方。

下面是 javaspecialists 中一篇文章对它的介绍：

This number represents the golden ratio (sqrt(5)-1) times two to the power of 31 ((sqrt(5)-1) * (2^31)). The result is then a golden number, either 2654435769 or -1640531527.

下面用例子来证明下：

private static final int HASH_INCREMENT = 0x61c88647;

public static void main(String[] args) throws Exception {
    int n = 5;
    int max = 2 << (n - 1);
    for (int i = 0; i < max; i++) {
        System.out.print(i * HASH_INCREMENT & (max - 1));
        System.out.print(" ");

    }
}

运行结果为：0 7 14 21 28 3 10 17 24 31 6 13 20 27 2 9 16 23 30 5 12 19 26 1 8 15 22 29 4 11 18 25

可以发现元素索引值完美的散列在数组当中，并没有出现冲突。

内部类ThreadLocalMap

ThreadLocalMap 是 ThreadLocal 的静态内部类，当一个线程有多个 ThreadLocal 时，需要一个容器来管理多个 ThreadLocal，ThreadLocalMap 的作用就是管理线程中多个 ThreadLocal。

ThreadLocalMap 其实就是一个简单的 Map 结构，底层是数组，有初始化大小，也有扩容阈值大小，数组的元素是 Entry。

ThreadLocalMap的数据结构是一个用数组表示的环，数组长度必须是2的次幂，同样通过hash方式确定节点在数组中的下标（hash值是ThreadLocal的递增变量，而不是hashcode值），对于hash冲突的情况，采用线性探测法，直接将元素防止对应下标后面的下一个空闲单元。

ThreadLocalMap的key采用的是弱引用WeakReference，因此在使用过程中还需要注意及时清理key已经被gc回收的节点，及时释放无效空间。

关于弱引用可以查看《Java基础 ｜强引用、弱引用、软引用、虚引用》

成员属性

// 初始容量，必须为 2 的幂
private static final int INITIAL_CAPACITY = 16;

// 存储 ThreadLocal 的键值对实体数组，长度必须为 2 的幂
private Entry[] table;

// ThreadLocalMap 元素数量
private int size = 0;

//扩容的阈值，默认是数组大小的三分之二
private int threshold; // Default to 0

Entry类

Entry是ThreadLocalMap的内部类，用来表示其中的节点，继承了弱引用WeadReference类。

// 键值对实体的存储结构
static class Entry extends WeakReference> {
    // 当前线程关联的 value，这个 value 并没有用弱引用追踪
    Object value;
    /**
     * 构造键值对
     *
     * @param k k 作 key,作为 key 的 ThreadLocal 会被包装为一个弱引用
     * @param v v 作 value
     */     
    Entry(ThreadLocal k, Object v) {
        super(k);
        value = v;
    }
}

Entry 的 key 就是 ThreadLocal 的引用，value 是 ThreadLocal 的值。同时，Entry也继承WeakReference，所以说Entry所对应key（ThreadLocal实例）的引用是一个弱引用。

弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。

构造方法

ThreadLocalMap 提供了两个构造方法：

1. ThreadLocalMap#ThreadLocalMap(ThreadLocal, Object)

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

• 根据第一个节点的key和value初始化map。
• 初始化数组，确定节点在数组的下标，初始化table[i]，设置size和threshold。
• 进行散列的hash值是ThreadLocal的threadLocalHashCode，递增生成。

2. ThreadLocalMap#ThreadLocalMap(ThreadLocalMap)

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