由浅入深全面解析threadlocalThreadLocal 的作用是：提供线程内的局部变量，不同的线程之间不会相互干扰

学习目标

了解ThreadLocal的介绍
掌握ThreadLocal的运用场景
了解ThreadLocal的内部结构
了解ThreadLocal的核心方法源码
了解ThreadLocalMap的源码

1. ThreadLocal介绍

1.1 官方介绍

从Java官方文档中的描述：ThreadLocal类用来提供线程内部的局部变量。这种变量在多线程环境下访问（通过get和set方法访问）时能保证各个线程的变量相对独立于其他线程内的变量。ThreadLocal实例通常来说都是private static类型的，用于关联线程和线程上下文。

我们可以得知 ThreadLocal 的作用是：提供线程内的局部变量，不同的线程之间不会相互干扰，这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或组件之间一些公共变量传递的复杂度。

总结:

线程并发: 在多线程并发的场景下
传递数据: 我们可以通过ThreadLocal在同一线程，不同组件中传递公共变量
线程隔离: 每个线程的变量都是独立的，不会互相影响

1.2 基本使用

1.2.1 常用方法

在使用之前,我们先来认识几个ThreadLocal的常用方法

1.2.2 使用案例

我们来看下面这个案例 , 感受一下ThreadLocal 线程隔离的特点： ` public class MyDemo { private String content;

private String getContent() {
    return content;
}

private void setContent(String content) {
    this.content = content;
}

public static void main(String[] args) {
    MyDemo demo = new MyDemo();
    for (int i = 0; i < 5; i++) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                demo.setContent(Thread.currentThread().getName() + "的数据");
                System.out.println("-----------------------");
         		System.out.println(Thread.currentThread().getName() + "--->" + demo.getContent());
            }
        });
        thread.setName("线程" + i);
        thread.start();
    }
}

} `

从结果可以看出多个线程在访问同一个变量的时候出现的异常，线程间的数据没有隔离。下面我们来看下采用 ThreadLocal 的方式来解决这个问题的例子。

` public class MyDemo1 {

private static ThreadLocal<String> tl = new ThreadLocal<>();

private String content;

private String getContent() {
    return tl.get();
}

private void setContent(String content) {
     tl.set(content);
}

public static void main(String[] args) {
    MyDemo demo = new MyDemo();
    for (int i = 0; i < 5; i++) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                demo.setContent(Thread.currentThread().getName() + "的数据");
                System.out.println("-----------------------");
                System.out.println(Thread.currentThread().getName() + "--->" + demo.getContent());
            }
        });
        thread.setName("线程" + i);
        thread.start();
    }
}

} `

从结果来看，这样很好的解决了多线程之间数据隔离的问题，十分方便。

1.3 ThreadLocal类与synchronized关键字

1.3.1 synchronized同步方式

这里可能有的朋友会觉得在上述例子中我们完全可以通过加锁来实现这个功能。我们首先来看一下用synchronized代码块实现的效果: ` public class Demo02 {

private String content;

public String getContent() {
    return content;
}

public void setContent(String content) {
    this.content = content;
}

public static void main(String[] args) {
    Demo02 demo02 = new Demo02();
    
    for (int i = 0; i < 5; i++) {
        Thread t = new Thread(){
            @Override
            public void run() {
                synchronized (Demo02.class){
                    demo02.setContent(Thread.currentThread().getName() + "的数据");
                    System.out.println("-------------------------------------");
                    String content = demo02.getContent();
                    System.out.println(Thread.currentThread().getName() + "--->" + content);
                }
            }
        };
        t.setName("线程" + i);
        t.start();
    }
}

} `

从结果可以发现, 加锁确实可以解决这个问题，但是在这里我们强调的是线程数据隔离的问题，并不是多线程共享数据的问题, 在这个案例中使用synchronized关键字是不合适的。

1.3.2 ThreadLocal与synchronized的区别

虽然ThreadLocal模式与synchronized关键字都用于处理多线程并发访问变量的问题, 不过两者处理问题的角度和思路不同。

2. 运用场景_事务案例

通过以上的介绍，我们已经基本了解ThreadLocal的特点。但是它具体是运用在什么场景中呢？接下来让我们看一个案例：事务操作。

2.1 转账案例 2.1.1 场景构建

这里我们先构建一个简单的转账场景：有一个数据表account，里面有两个用户Jack和Rose，用户Jack 给用户Rose 转账。

2.3 ThreadLocal解决方案

2.3.1 ThreadLocal方案的实现

像这种需要在项目中进行数据传递和线程隔离的场景，我们不妨用ThreadLocal来解决：

（1）工具类的修改：加入ThreadLocal

` public class JdbcUtils { //ThreadLocal对象 : 将connection绑定在当前线程中 private static final ThreadLocal tl = new ThreadLocal();

// c3p0 数据库连接池对象属性
private static final ComboPooledDataSource ds = new ComboPooledDataSource();

// 获取连接
public static Connection getConnection() throws SQLException {
    //取出当前线程绑定的connection对象
    Connection conn = tl.get();
    if (conn == null) {
        //如果没有，则从连接池中取出
        conn = ds.getConnection();
        //再将connection对象绑定到当前线程中
        tl.set(conn);
    }
    return conn;
}

//释放资源
public static void release(AutoCloseable... ios) {
    for (AutoCloseable io : ios) {
        if (io != null) {
            try {
                io.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

public static void commitAndClose() {
    try {
        Connection conn = getConnection();
        //提交事务
        conn.commit();
        //解除绑定
        tl.remove();
        //释放连接
        conn.close();
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

public static void rollbackAndClose() {
    try {
        Connection conn = getConnection();
        //回滚事务
        conn.rollback();
        //解除绑定
        tl.remove();
        //释放连接
        conn.close();
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

}

2.3.2 ThreadLocal方案的好处

从上述的案例中我们可以看到，在一些特定场景下，ThreadLocal方案有两个突出的优势：

传递数据：保存每个线程绑定的数据，在需要的地方可以直接获取, 避免参数直接传递带来的代码耦合问题

线程隔离：各线程之间的数据相互隔离却又具备并发性，避免同步方式带来的性能损失

3. ThreadLocal的内部结构

通过以上的学习，我们对ThreadLocal的作用有了一定的认识。现在我们一起来看一下ThreadLocal的内部结构，探究它能够实现线程数据隔离的原理。

3.1 常见的误解

如果我们不去看源代码的话，可能会猜测ThreadLocal是这样子设计的：每个ThreadLocal都创建一个Map，然后用线程作为Map的key，要存储的局部变量作为Map的value，这样就能达到各个线程的局部变量隔离的效果。这是最简单的设计方法，JDK最早期的ThreadLocal 确实是这样设计的，但现在早已不是了。

3.2 现在的设计

但是，JDK后面优化了设计方案，在JDK8中 ThreadLocal的设计是：每个Thread维护一个ThreadLocalMap，这个Map的key是ThreadLocal实例本身，value才是真正要存储的值Object。

具体的过程是这样的：

每个Thread线程内部都有一个Map (ThreadLocalMap)
Map里面存储ThreadLocal对象（key）和线程的变量副本（value）
Thread内部的Map是由ThreadLocal维护的，由ThreadLocal负责向map获取和设置线程的变量值。
对于不同的线程，每次获取副本值时，别的线程并不能获取到当前线程的副本值，形成了副本的隔离，互不干扰。

3.3 这样设计的好处

这个设计与我们一开始说的设计刚好相反，这样设计有如下两个优势：

这样设计之后每个Map存储的Entry数量就会变少。因为之前的存储数量由Thread的数量决定，现在是由ThreadLocal的数量决定。在实际运用当中，往往ThreadLocal的数量要少于Thread的数量。
当Thread销毁之后，对应的ThreadLocalMap也会随之销毁，能减少内存的使用。

了解ThreadLocal类

变量值的共享可以使用public static变量的形式，所有的线程都使用同一个public static变量。如果想实现每一个线程都有自己的共享变量该如何解决呢？JDK中提供的类ThreadLocal正是为了解决这样的问题。

类ThreadLocal主要解决每个线程绑定自己的值，可以将ThreadLocal比喻成全局存放数据的盒子，盒子中可以存储每个线程的私有数据。

如果你创建了一个ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的本地副本，这也是ThreadLocal变量名的由来。他们可以使用 get（）和 set（）方法来获取默认值或将其值更改为当前线程所存的副本的值，从而避免了线程安全问题。

再举个简单的例子：

比如有两个人去宝屋收集宝物，这两个共用一个袋子的话肯定会产生争执，但是给他们两个人每个人分配一个袋子的话就不会出现这样的问题。如果把这两个人比作线程的话，那么ThreadLocal就是用来避免这两个线程竞争的。

首先，它是一个数据结构，有点像HashMap，可以保存"key : value"键值对，但ThreadLocal只能保存一个，并且各个线程的数据互不干扰。

ThreadLocal<String> localName = new ThreadLocal();
localName.set("小明");
String name = localName.get();

在线程1中初始化了一个ThreadLocal对象localName，并通过set方法，保存了一个值小明，同时在线程1中通过localName.get()可以拿到之前设置的值，但是如果在线程2中，拿到的将是一个null。这是为什么，如何实现？不过之前也说了，ThreadLocal保证了各个线程的数据互不干扰。看看set(T value)和get()方法的源码。

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

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

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

可以发现，每个线程中都有一个ThreadLocalMap数据结构，当执行set方法时，其值是保存在当前线程的threadLocals变量中，当执行set方法中，是从当前线程的threadLocals变量获取。所以在线程1中set的值，对线程2来说是摸不到的，而且在线程2中重新set的话，也不会影响到线程1中的值，保证了线程之间不会相互干扰。那每个线程中的ThreadLoalMap究竟是什么？

以上ThreadLoalMap本文分析的是1.7的源码。从名字上看，可以猜到它也是一个类似HashMap的数据结构，但是在ThreadLocal中，并没实现Map接口。在ThreadLoalMap中，也是初始化一个大小16的Entry数组，Entry对象用来保存每一个key-value键值对，只不过这里的key永远都是ThreadLocal对象，是不是很神奇，通过ThreadLocal对象的set方法，结果把ThreadLocal对象自己当做key，放进了ThreadLoalMap中。

这里需要注意的是，ThreadLoalMap的Entry是继承WeakReference，和HashMap很大的区别是，Entry中没有next字段，所以就不存在链表的情况了。

hash冲突没有链表结构，那发生hash冲突了怎么办？

先看看ThreadLoalMap中插入一个key-value的实现

private void set(ThreadLocal<?> key, Object value) {
    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)]) {
        ThreadLocal<?> k = e.get();

        if (k == key) {
            e.value = value;
            return;
        }
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }
    tab[i] = new Entry(key, value);
    int sz = ++size;
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

每个ThreadLocal对象都有一个hash值threadLocalHashCode，每初始化一个ThreadLocal对象，hash值就增加一个固定的大小0x61c88647。在插入过程中，根据ThreadLocal对象的hash值，定位到table中的位置i，过程如下：

如果当前位置是空的，那么正好，就初始化一个Entry对象放在位置i上；

不巧，位置i已经有Entry对象了，如果这个Entry对象的key正好是即将设置的key，那么重新设置Entry中的value；很不巧，位置i的Entry对象，和即将设置的key没关系，那么只能找下一个空位置；这样的话，在get的时候，也会根据ThreadLocal对象的hash值，定位到table中的位置，然后判断该位置Entry对象中的key是否和get的key一致，如果不一致，就判断下一个位置可以发现，set和get如果冲突严重的话，效率很低，因为ThreadLoalMap是Thread的一个属性，所以即使在自己的代码中控制了设置的元素个数，但还是不能控制其它代码的行为。

内存泄露

ThreadLocal可能导致内存泄漏，为什么？先看看Entry的实现：static class Entry extends

WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;
    Entry(ThreadLocal<?> k, Object v) {
        super(k);
        value = v;
    }
}

通过之前的分析已经知道，当使用ThreadLocal保存一个value时，会在ThreadLocalMap中的数组插入一个Entry对象，按理说key-value都应该以强引用保存在Entry对象中，但在ThreadLocalMap的实现中，key被保存到了WeakReference对象中。这就导致了一个问题，ThreadLocal在没有外部强引用时，发生GC时会被回收，如果创建ThreadLocal的线程一直持续运行，那么这个Entry对象中的value就有可能一直得不到回收，发生内存泄露。

什么是弱引用

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

弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

如何避免内存泄露

既然已经发现有内存泄露的隐患，自然有应对的策略，在调用ThreadLocal的get()、set()可能会清除ThreadLocalMap中key为null的Entry对象，这样对应的value就没有GC Roots可达了，下次GC的时候就可以被回收，当然如果调用remove方法，肯定会删除对应的Entry对象。如果使用ThreadLocal的set方法之后，没有显示的调用remove方法，就有可能发生内存泄露，所以养成良好的编程习惯十分重要，使用完ThreadLocal之后，记得调用remove方法。

ThreadLocal<String> localName = new ThreadLocal();
try {
    localName.set("小狼");
    // 其它业务逻辑
} finally {
    localName.remove();
}

参考：

juejin.im/post/684490…
java多线程编程核心技术
javaguide.cn/2019/12/09/…

由浅入深，全面解析ThreadLocal