(七)全面剖析Java并发编程之线程变量副本ThreadLocal原理分析

引言

在之前的文章：彻底理解Java并发编程之Synchronized关键字实现原理剖析中我们曾初次谈到线程安全问题引发的"三要素"：多线程、共享资源/临界资源、非原子性操作，简而言之：在同一时刻，多条线程同时对临界资源进行非原子性操作则有可能产生线程安全问题。而如果想要解决线程安全问题，我们只需要破坏掉三要素中的任意条件即可，如下：

• ①破坏多线程条件：同一时刻，一条线程对共享资源进行非原子性操作，不会产生线程安全问题
• ②破坏共享资源条件：同一时刻多条线程对局部资源进行非原子性操作，也不会产生线程安全问题
• ③破坏非原子性条件：同一时刻多条线程对共享资源进行原子性操作，也不会产生线程安全问题

“三要素”说法仅是个人理解，如有疑义可纠正

而在前面的文章中，我们曾谈到过CAS无锁机制、Synchronized隐式锁、ReetrantLock显式锁等都可以解决线程安全问题。而在这些方案当中，CAS机制是利用上面第三点：破坏非原子性条件，保证原子性来解决线程安全问题；Synchronized与ReetrantLock则是利用上述第一点：破坏多线程条件，在同一时刻只允许一条线程访问临界资源解决此问题。而本文谈到的ThreadLocal则是通过如上第二点：破坏共享资源条件解决线程安全问题。

一、ThreadLocal概念及使用浅析

ThreadLocal线程本地副本，在很多地方也被称为线程本地变量、线程局部存储等叫法，但总归来说都是形容ThreadLocal这一个东西。在执行时，ThreadLocal会为变量在每一条线程创建一个副本，这个副本只有每条线程自己可以访问。下面我们可以先看看ThreadLocal类以及它提供的一些方法：

// 省略方法体(后面源码再详细分析)
public class ThreadLocal {
    // 构造函数
    public ThreadLocal() {}
    
    // 初始化方法：在创建ThreadLocal对象时可以使用该方法进行初始化设值
    protected T initialValue()
    
    // 获取ThreadLocal在当前线程中保存的变量副本
    public T get() 
    
    // 设置当前线程中变量的副本
    public void set(T value)
    
    // 移除当前线程中变量的副本
    public void remove()
    
    // 内部子类：扩展了ThreadLocal的初始化值的方法，支持Lambda表达式赋值
    static final class SuppliedThreadLocal extends ThreadLocal
    
    // 内部类：定制的hashMap，仅用于维护当前线程的本地变量值。
    // 仅ThreadLocal类对其有操作权限，是Thread的私有属性。
    // 为避免占用空间较大或生命周期较长的数据常驻于内存引发一系列问题，
    // hashtable的key是弱引用WeakReferences。
    // 当堆空间不足时，会清理未被引用的entry。
    static class ThreadLocalMap
    
    // 省略其他代码.......
}

如上便是ThreadLocal提供的一些主要方法，在创建ThreadLocal对象时可以initialValue()对变量副本进行初始化，也可以使用set()方法更改值或者设置线程变量副本，使用get()方法获取变量副本，而remove()则可以移除当前线程中变量的副本。我们先来看一个例子：

public class DBUtils {
    private static Connection connection = null;

    public static Connection getConnection() throws SQLException {
        if (connection == null)
            connection = DriverManager.getConnection(
                    "jdbc:mysql:127.0.0.1:3306/test?user=root＆password=root");
        return connection;
    }

    public static void closeConnection() throws SQLException {
        if (connection != null)
            connection.close();
    }
}

假设有上面这么一个数据库连接工具类DBUtils，如上代码在单线程的环境下运行是没有问题的，但是如果把这个工具类丢在多线程的情况下则会出现问题。很显然，在获取连接getConnection()方法中，同一时刻如果有多条线程同时执行if (connection == null)判断则很有可能会导致创建多个连接对象。而因为connection是共享资源，所以在操作时也应该保证线程安全问题，不然在多线程情况下可能会造成：一条线程还在执行SQL，另外一条线程则调用closeConnection()方法关闭了连接对象。

所以如上这个例子我们该怎么解决遇到的问题？简单~

public class DBUtils {
    private static volatile Connection connection = null;

    public synchronized static Connection getConnection() throws SQLException {
        if (connection == null)
            connection = DriverManager.getConnection(
                    "jdbc:mysql:127.0.0.1:3306/test?user=root＆password=root");
        return connection;
    }

    public synchronized static void closeConnection() throws SQLException {
        if (connection != null)
            connection.close();
    }
}

我们在共享变量connection加上volatile关键字修饰以及在操作临界资源的方法上添加synchronized关键字修饰，这样就能保证线程安全。或者我们也可以这样：

public class DBUtils {
    private static volatile Connection connection = null;
    private static ReentrantLock lock = new ReentrantLock();

    public static Connection getConnection() throws SQLException {
        lock.lock(); //获取锁
        if (connection == null)
            connection = DriverManager.getConnection(
                    "jdbc:mysql:127.0.0.1:3306/test?user=root＆password=root");
        lock.unlock(); // 释放锁
        return connection;
    }

    public static void closeConnection() throws SQLException {
        lock.lock(); //获取锁
        if (connection != null)
            connection.close();
        lock.unlock(); // 释放锁
    }
}

但是上面的两种方式确实可以保证线程安全，但是带来的弊端也很明显：

当一条线程在执行SQL时，其他线程只能等待当前线程先处理完成之后才可以获取连接，这样会大大的影响程序的效率。

我们可以思考一下，此处到底是否需要将connection对象变成共享资源？结果显而易见，其实是不需要的，因为每条线程可以持有一个connection对象进行DB操作，每条线程之间对connection对象的操作是不存在任何依赖关系的。那我们能不能这样？

public class DBUtils {
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(
                    "jdbc:mysql:127.0.0.1:3306/test?user=root＆password=root");;
    }

    public static void closeConnection(Connection connection) throws SQLException {
        if (connection != null)
            connection.close();
    }
}

理论上是可行的，因为由于每次线程操作DB时创建的都是不同的连接对象，自然也就不存在线程安全问题。但是由于线程每次访问DB都需要创建一个新的连接对象，用完之后再次关闭，在执行过程中会频繁的获取/关闭数据库连接，这样不但影响系统整体效率，还会导致给DB服务器造成巨大的压力，严重的情况下甚至会直接导致系统崩溃。

那么在这种情况下时，我们就可以使用ThreadLocal来解决此类问题，如下：

public class DBUtils {
    private static ThreadLocal connectionHolder =
    new ThreadLocal(){
        @SneakyThrows
        public Connection initialValue(){
            return DriverManager.getConnection(
                    "jdbc:mysql:127.0.0.1:3306/test?user=root＆password=root");
        }
    };

    public static Connection getConnection() throws SQLException {
        return connectionHolder.get();
    }
}

在如上例子中，我们可以使用ThreadLocal为每个线程创建一个Connection变量副本，从而达到我们最开始所说的：ThreadLocal通过破坏共享资源条件解决线程安全问题，每条执行的线程操作的都是自己本地的副本变量，自然也就不构成“三要素”。

ThreadLocal使用场景

• ①上下文(context)传递。一个对象需要在多个方法中层次传递使用，比如用户身份、任务信息、调用链ID、关联ID(如日志的uniqueID，方便串起多个日志)等，如果此时使用责任链模式给每个方法添加一个context参数会比较麻烦，而此时就可以使用ThreadLocal设置参数，需要使用时get一下即可。
• ②线程间的数据隔离。如spring事务管理机制实现则使用到ThreadLocal来保证单个线程中的数据库操作使用的是同一个数据库连接。同时，采用这种方式可以使业务层使用事务时不需要感知并管理Connection连接对象，通过传播级别，能够巧妙地管理多个事务配置之间的切换，挂起和恢复。
• ③ThreadLocal一般情况下，我们在项目开发过程中很少使用，而它更多应用则是在框架源码中应用，如Spring框架的事务隔离机制中的TransactionSynchronizationManager类，也包括Netty框架中的二次封装类FastThreadLocal等。
• ④上个ThreadLocal的应用案例：

// 日期工具类
private static ThreadLocal threadLocal = 
        ThreadLocal.withInitial(()-> 
            new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));

public static Date parse(String dateStr) {
    Date date = null;
    try {
        date = threadLocal.get().parse(dateStr);
    } catch (ParseException e) {
        e.printStackTrace();
    }
    return date;
}

二、ThreadLocal原理分析

在前面我们对ThreadLocal进行了简单的讲解，而ThreadLocal作为一个存储类型的类，重点就是读写get()与set()。现在我们则可以深入源码去一探ThreadLocal的神秘面纱。

2.1、ThreadLocal创建变量副本原理分析

先从ThreadLocal.set()方法开始：

// ThreadLocal类 → set()方法
public void set(T value) {
    // 获取当前执行线程
    Thread t = Thread.currentThread();
    // 获取当前线程的threadlocals成员变量
    ThreadLocalMap map = getMap(t);
    // 如果map不为空，则将value添加进map
    if (map != null)
        map.set(this, value);
    // 如果map为空则先为当前线程创建一个map再将value加入map
    else
        createMap(t, value);
}

ThreadLocal.set()方法中总归来说分为三步：

• 调用getMap()获取当前线程的ThreadLocalMap
• 如果map不为空则将传入的value值添加进map
• 如果map为空则先为当前线程创建一个map再将value加入map

首先来看看getMap(Thread)方法：

// ThreadLocal类 → getMap()方法
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

是不是有些意外？在getMap(Thread)方法中是调用当前线程对象的成员变量threadLocals并返回的：

Thread类：ThreadLocal.ThreadLocalMap threadLocals = null;

可以看到，Thread类的成员变量threadLocals实则就是ThreadLocalMap，而ThreadLocalMap则是一个给ThreadLocal定制版的HashMap，也是ThreadLocal的内部类，如下：

// ThreadLocal类
public class ThreadLocal {
    // ThreadLocal内部类：ThreadLocalMap
    static class ThreadLocalMap {
        // ThreadLocalMap内部类：Entry
        static class Entry extends WeakReference> {
            Object value;
            Entry(ThreadLocal k, Object v) {
                super(k);
                value = v;
            }
        }
    }
}

在ThreadLocalMap类中还存在一个内部类Entry，继承自WeakReference弱引用类型，结构如下：

ThreadLocal结构图

再来看看createMap()方法：

// ThreadLocal类 → createMap()方法
void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

至此，我们应该已经明白了ThreadLocal是如何为每个线程创建变量副本的：

在每条线程Thread内部有一个ThreadLocal.ThreadLocalMap类型的成员变量threadLocals，这个threadLocals就是每条线程用来存储变量副本的，key值为当前ThreadLocal对象，value为变量副本（即T类型的变量）。每个Thread线程对象最开始的threadLocals都为空，当线程调用ThreadLocal.set()或ThreadLocal.get()方法时(get方法待会而会分析到)，都会调用createMap()方法对threadLocals进行初始化。然后在当前线程里面，如果要使用副本变量，就可以通过get方法在threadLocals里面查找。

原理如下：

ThreadLocal创建变量副本原理

2.2、ThreadLocal获取变量副本原理分析

在上述过程中，我们已经分析了ThreadLocal创建变量副本原理，接下来我们再看看ThreadLocal.get()方法：

// ThreadLocal类 → get()方法
public T get() {
    // 获取当前执行线程
    Thread t = Thread.currentThread();
    // 获取当前线程的ThreadLocalMap
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        // 如果map不为空，将当前ThreadLocal对象作为key获取对应值
        ThreadLocalMap.Entry e = map.getEntry(this);
        // 如果获取的值不为空则返回获取到的value
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    // 如果map为空则调用setInitialValue方法
    return setInitialValue();
}

在ThreadLocal.get()方法中，总归来说分为三步：

• 获取到当前执行线程，通过getMap(Thread)方法获取ThreadLocalMap类型的map
• 将当前ThreadLocal对象this作为key尝试获取map中的键值对，获取成功返回value
• 如果第一步获取的map为空则调用setInitialValue()方法返回value

调用get()方法之后首先会获取当前线程的threadLocals成员变量(即ThreadLocalMap)，如map不为空则以为this作为key获取ThreadLocal中存储的变量副本，如果为空则调用setInitialValue()方法：

// ThreadLocal类 → setInitialValue()方法
private T setInitialValue() {
    // 获取ThreadLocal初始化值
    T value = initialValue();
    Thread t = Thread.currentThread();
    // 获取当前线程的map
    ThreadLocalMap map = getMap(t);
    // 如果map不为空则将初始化值添加进map容器
    if (map != null)
        map.set(this, value);
    // 如果map为空则创建一个ThreadLocalMap容器
    else
        createMap(t, value);
    return value;
}

// ThreadLocal类 → initialValue()()方法
protected T initialValue() {
    return null;
}

setInitialValue()与前面分析的ThreadLocal.set(value)方法有些类似，在setInitialValue()方法中首先会调用initialValue()方法获取初始化值，而initialValue()方法默认是返回空的，但是initialValue()方法可以在创建ThreadLocal对象时进行重写，如下：

private static ThreadLocal