在这里插入图片描述

1.概述

ThreadLocal 不是一个线程，而是一个线程的本地化对象。当某个变量在使用 ThreadLocal 进行维护时，ThreadLocal 为使用该变量的每个线程分配了一个独立的变量副本，每个线程可以自行操作自己对应的变量副本，而不会影响其他线程的变量副本。

1.1 什么是ThreadLocal变量

ThreadLoal 变量，线程局部变量，同一个 ThreadLocal 所包含的对象，在不同的 Thread 中有不同的副本。这里有几点需要注意：

因为每个 Thread 内有自己的实例副本，且该副本只能由当前 Thread 使用。这是也是 ThreadLocal 命名的由来。
既然每个 Thread 有自己的实例副本，且其它 Thread 不可访问，那就不存在多线程间共享的问题。

ThreadLocal 提供了线程本地的实例。它与普通变量的区别在于，每个使用该变量的线程都会初始化一个完全独立的实例副本。ThreadLocal 变量通常被private static修饰。当一个线程结束时，它所使用的所有 ThreadLocal 相对的实例副本都可被回收。

总的来说，ThreadLocal 适用于每个线程需要自己独立的实例且该实例需要在多个方法中被使用，也即变量在线程间隔离而在方法或类间共享的场景。

2.API 方法

ThreadLocal 的 API 提供了如下的 4 个方法。

protected T initialValue() 返回当前线程的局部变量副本的变量初始值。
T get() 返回当前线程的局部变量副本的变量值，如果此变量副本不存在，则通过 initialValue() 方法创建此副本并返回初始值。
void set(T value) 设置当前线程的局部变量副本的变量值为指定值。
void remove() 删除当前线程的局部变量副本的变量值。

在实际使用中，我们一般都要重写 initialValue() 方法，设置一个特定的初始值。

4.源码

在这里插入图片描述

ThreadLocal是线程本地变量，因此每个Thread对象内部必然存储ThreadLocal，ThreadLocal作为key，存储在ThreadLocalMap中。

每个Thread维护一个ThreadLocalMap映射表，这个映射表的key是ThreadLocal实例本身，value是真正需要存储的Object。也就是说ThreadLocal本身不存储值，它只是作为一个key来让线程从ThreadLocalMap获取value。值得注意的是图中（图片摘自网络）的虚线，表示ThreadLocalMap是使用ThreadLocal的弱引用作为key的，弱引用的对象在GC时会被回收。

class Thread {
    ThreadLocal.ThreadLocalMap threadLocals = null; //每个线程对象内部维护了一个ThreadLocal.ThreadLocalMap。
    ...
}

4.1 ThreadLocal

ThreadLocal主要方法就是set，get,

拿到当前线程对象。
拿到线程对象内部维护的ThreadLocalMap对象。
一个线程对象中只有一个ThreadLocalMap对象，所有ThreadLocal对象及这个ThreadLocal对象存储的值都以key-value的3. 形式存在ThreadLocalMap中。（ThreadLocalMap的key是ThreadLocal对象，value是需要存储的变量。）

4.1.1 set

public class ThreadLocal<T> {

    static class ThreadLocalMap {...} //ThreadLocalMap是ThreadLocal的静态内部类
    ...

    public void set(T value) {
        Thread t = Thread.currentThread(); //拿到当前线程
        ThreadLocalMap map = getMap(t); //取出线程维护的ThreadLocalMap
        if (map != null)
            map.set(this, value); //ThreadLocalMap的key为当前ThreadLocal对象，value就是我们需要存储的变量
        else
            createMap(t, value); //该线程第一次使用ThreadLocal.set时创建ThreadLocalMap对象,并赋值。
    }

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

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

}

4.1.2 get

public class ThreadLocal<T> {

    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t); //从当前线程取出ThreadLocalMap
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this); //以当前ThreadLocal对象为key取出ThreadLocalMap.Entry
            if (e != null) {
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue(); //如果这个ThreadLocal对象没有赋值直接get，会给它赋值为null并返回。
    }

    private T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }

    protected T initialValue() {
        return null;
    }　　...

}

5.ThreadLocal 与 Thread 同步机制的比较

同步机制采用了以时间换空间方式，通过对象锁保证在同一个时间，对于同一个实例对象，只有一个线程访问。
ThreadLocal 采用以空间换时间方式，为每一个线程都提供一份变量，各线程间同时访问互不影响。

6.缺点

6.1 内存泄漏问题

实际上 ThreadLocalMap 中使用的 key 为 ThreadLocal 的弱引用，弱引用的特点是，如果这个对象只存在弱引用，那么在下一次垃圾回收的时候必然会被清理掉。

所以如果 ThreadLocal 没有被外部强引用的情况下，在垃圾回收的时候会被清理掉的，这样一来 ThreadLocalMap中使用这个 ThreadLocal 的 key 也会被清理掉。但是，value 是强引用，不会被清理，这样一来就会出现 key 为 null 的 value。

ThreadLocalMap实现中已经考虑了这种情况，在调用 set()、get()、remove() 方法的时候，会清理掉 key 为 null 的记录。如果说会出现内存泄漏，那只有在出现了 key 为 null 的记录后，没有手动调用 remove() 方法，并且之后也不再调用 get()、set()、remove() 方法的情况下。

7.使用场景

如上文所述，ThreadLocal 适用于如下两种场景

每个线程需要有自己单独的实例
实例需要在多个方法中共享，但不希望被多线程共享

对于第一点，每个线程拥有自己实例，实现它的方式很多。例如可以在线程内部构建一个单独的实例。ThreadLoca 可以以非常方便的形式满足该需求。

对于第二点，可以在满足第一点（每个线程有自己的实例）的条件下，通过方法间引用传递的形式实现。ThreadLocal 使得代码耦合度更低，且实现更优雅。

7.1 存储用户Session

一个简单的用ThreadLocal来存储Session的例子：

  private static final ThreadLocal threadSession = new ThreadLocal();

    public static Session getSession() throws InfrastructureException {
        Session s = (Session) threadSession.get();
        try {
            if (s == null) {
                s = getSessionFactory().openSession();
                threadSession.set(s);
            }
        } catch (HibernateException ex) {
            throw new InfrastructureException(ex);
        }
        return s;
    }

7.2 存储数据库连接对象Connection

事务控制是通过Connection实现的，而Connection又是非线程安全的，所以当多线程访问时，每个线程必须要有自己独立的Connection对象，才能实现只控制自己的事务，而不会和其它线程的事务混淆。）

一个简单的用ThreadLocal来存储Connection的例子：

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
@Component
public class ConnectionTest {
    private ThreadLocal<Connection> connections = new ThreadLocal();
    @Autowired
    private DataSource dataSource;
    public Connection getConnection() throws SQLException {
        Connection conn = connections.get();
            if (conn == null) {
                //当前线程获取不到连接，就新建个连接对象
                conn=dataSource.getConnection();
                //保存到当前线程对应的ThreadLocalMap里
                connections.set(conn);
            }
        return conn;
    }
}

7.3 解决线程安全的问题

比如Java7中的SimpleDateFormat不是线程安全的，可以用ThreadLocal来解决这个问题：

参考：【Java】ThreadLocal SimpleDateFormat 静态代码块空指针异常

参考：【Java】Java SimpleDateFormat 线程安全问题

public class DateUtil {
    private static ThreadLocal<SimpleDateFormat> format1 = new ThreadLocal<SimpleDateFormat>() {
        @Override
        protected SimpleDateFormat initialValue() {
            return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        }
    };

    public static String formatDate(Date date) {
        return format1.get().format(date);
    }
}

这里的DateUtil.formatDate()就是线程安全的了。(Java8里的 java.time.format.DateTimeFormatter是线程安全的，Joda time里的DateTimeFormat也是线程安全的）。

参考：https://segmentfault.com/a/1190000009236777

【Java】Java中ThreadLocal简介