本文对ThreadLocal的分析基于JDK 8。

本文大纲

　　1.

　　2.

　　3.

　　4.

1. ThreadLocal快速上手

　　ThreadLocal是java.lang包下的一个类，它可以为每个线程维护一份独立的变量副本。当线程运行结束后，线程内部的引用的指向的实例副本都会被回收。

　　对于初次接触ThreadLocal的同学来说，看了上面这段话可能还是蒙的，下面我们通过简单的例子快速上手ThreadLocal。

　　我们先看看不使用ThreadLocal的情况下，让两个线程共享一个打印Task进行打印输出：

public class ThreadLocalTest1 {    public static void main(String[] args) {        Runnable task = new Task();        new Thread(task, "t1").start();        new Thread(task, "t2").start();    }    static class Task implements Runnable {        Integer counter = 0; // 多个线程共享的实例        @Override        public void run() {            while (true) {                System.out.println(Thread.currentThread().getName() + " -> " + counter++);                try {                    Thread.sleep(1000L);                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        }    }}

 　　毫无疑问，上面这段代码对counter的操作不是线程安全的，因为counter是两个线程间共享的，所以一个线程对counter的修改操作可能会影响另一个线程对counter的输出，下面我节选了部分输出结果：

t2 -> 0t1 -> 0 // t1线程打印0t2 -> 1t1 -> 2 // t1线程打印couter从0直接跳到了2，因为t0线程对counter做了修改t2 -> 3t1 -> 3

　　　可以从下图看出两个线程共享counter大致模型：

　

 　　假设，现在有一个需求，要求t1和t2各自分别进行计数并打印，那么这时我们就可以使用ThreadLocal了，代码如下：

public class ThreadLocalTest1 {    public static void main(String[] args) {        Runnable task = new Task();        new Thread(task, "t1").start();        new Thread(task, "t2").start();    }    static class Task implements Runnable {        ThreadLocal
     
       cntTl = new ThreadLocal
      
       () {            protected Integer initialValue() {                return 0; // 设置初始值为0            }        };        @Override        public void run() {            while (true) {                Integer counter = cntTl.get(); // 获取值                System.out.println(Thread.currentThread().getName() + " -> " + counter++);                cntTl.set(counter); // counter++后，将counter值设置回去                try {                    Thread.sleep(1000L);                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        }    }}
      
     

 　　运行上面代码的部分输出结果：

t1 -> 0t2 -> 0t1 -> 1t2 -> 1t1 -> 2t2 -> 2t1 -> 3t2 -> 3

　　可以看到，t1和t2两个线程分别按顺序输出了1、2、3......这就是因为上面提到过的ThreadLocal为每个线程都维护了一份数据的副本，在本例中的体现就是两个线程t1、t2中都各自有一个counter，t1和t2线程各自操作自己的counter，因此对其中一个counter的数据进行修改不会对另一个counter产生影响。

　　使用ThreadLocal后的模型：

 

 　　我们再理解深入一点，每个线程都有一个ThreadLocalMap对象，ThreadLocalMap是ThreadLocal的一个内部类：

/* ThreadLocal values pertaining to this thread. This map is maintained * by the ThreadLocal class. */ThreadLocal.ThreadLocalMap threadLocals = null; // Thread类中的threadLocals属性

 　　线程t1和t2各自都有一个ThreadLocalMap对象，暂且就把它看成一个Map就行，这个Map以当前ThreadLocal对象为key，value为我们要保存的值。当使用cntTl调用get方法时，其实是以当前ThreadLocal对象为key去获取对应的value。

2. ThreadLocal应用场景

 　　ThreadLocal主要有如下两种应用场景：

　　1. 每个线程需要单独维护一个对象实例，就像在提到的那样；

　　2. 在同一线程执行的不同方法中共享对象实例。

　　下面将重点分析第2种应用场景。熟悉Web开发的同学都知道MVC模型，C（Controller）会调用Service，Service调用DAO，DAO会使用Connection去连接数据库。在直接使用JDBC和数据库通信的情况下，我们需要在Service中创建Connection对象，然后打开事务，并将Connection以参数的形式传递给DAO，DAO使用Connection对象与数据库进行（开启事务的Connection和执行SQL的Connection必须是同一个），交互完成后我们在Service层进行事务的提交或者回滚。在不使用ThreadLocal的情况下，我们可能会这样写代码：

　　一个SqlRunner类用于执行SQL:

public class SqlRunner {    public void save(Connection connection, String sql, Object data) {        System.out.println("sql: " + sql + " executed successfully");    }}

　　Dao调用SqlRunner：

public class Dao {    public void save(Connection connection, Object data) { // 接收Connection        SqlRunner sqlRunner = new SqlRunner();        sqlRunner.save(connection, "insert into ...", data);    }}

　　Service调用Dao：

public class Service {    Dao dao = new Dao();    public void save(Object data) {        Connection connection = new Connection(); // 创建Connection        connection.beginTransaction(); // 开启事务        dao.save(connection, data); // 传入connection对象        connection.commit(); // 提交事务    }}

　　测试类：

public class ServiceTest {    public static void main(String[] args) {        Service service = new Service();        service.save("test data");    }}

　　控制台输出：

transaction begindata: test data, sql: insert into ... executed successfullytransaction commit

　　因为开启事务的Connection和执行SQL的Connection必须是同一个，所以可以看到Service中将创建的Connection以参数的方式传给了Dao，但是这种以传参的方式共享Connection会导致每个调用Dao方法的Service都必须传递Connection，显得太不优雅，下面我们将使用ThreadLocal来改变这种局面。

　　SqlRunner和上面的一样，这里不再贴出代码。

　　新增一个DataSource类：

public class DataSource {    private static ThreadLocal
     
       tl = new ThreadLocal<>(); // 使用ThreadLocal包装Connection    public static void beginTransaction() {        getCurrentConnection().beginTransaction(); // 开启事务    }    public static void commit() {        getCurrentConnection().commit(); // 提交事务    }    public static Connection getCurrentConnection() {        Connection connection = tl.get(); // 从ThreadLocal对象tl获取connection        if (connection == null) {            connection = getConnection(); // 没有和当前线程绑定的connection，则新建一个            tl.set(connection); // 将新建的connection与当前线程绑定        }        return connection;    }    private static Connection getConnection() {        return new Connection(); // 创建线程    }}
     

　　Dao：

public class Dao {    public void save(Object data) {        SqlRunner sqlRunner = new SqlRunner();        Connection connection = DataSource.getCurrentConnection(); // 获取与当前线程绑定的connection        System.out.println("connection in dao: " + connection); // 打印Dao中的connection对象        sqlRunner.save(connection, "insert into ...", data);    }}

　　Service：

public class Service {    Dao dao = new Dao();    public void save(Object data) {        DataSource.beginTransaction(); // 使用Connection开启事务        dao.save(data);        System.out.println("connection in dao: " + DataSource.getCurrentConnection()); // 打印Service中connection对象        DataSource.commit(); // 提交事务    }}

　　测试类和上面的ServiceTest相同，这里不再贴出。

　　控制台输出：

transaction beginconnection in Dao: com.andywooh.texplore.demo.concurrency.threadlocal.Connection@15db9742data: test data, sql: insert into ... executed successfullyconnection in Service: com.andywooh.texplore.demo.concurrency.threadlocal.Connection@15db9742transaction commit

　　可以看到，在Service中的connection和Dao中的Connection是同一个对象。

　　简单对ThreadLocal方式在同一个线程中、不同方法间共享connection对象做一个分析：调用Service的save方法，在开启事务前会先使用DataSource的getCurrentConnection去获得一个连接，由于是第一次获取connection，此时还没有和当前线程绑定的connection对象，所以会调用getConnection方法区创建一个connection对象，并将这个connection对象和当前线程进行绑定。当在同一个线程中在Dao里再一次调用getCurrentConnection时，由于已经有一个connection和当前线程绑定，所以就会直接返回该connection对象，这样就实现了不传参但是却在Service和Dao中使用同一个Connectiond的功能。

3. TheadLocal set与get方法简析

　　下面对ThreadLocal的set和get方法进行分析。再次说明一下，每个线程都包含一个ThreadLocalMap，我们先将其当成一个Map就行，ThreadLocalMap是ThreadLocal的一个内部类，这个Map中存储了我们想要和当前线程绑定的值，其中key是当前ThreadLocal对象，value是我们想要保存的值。

　　set方法：

public void set(T value) {    Thread t = Thread.currentThread(); // 获取当前线程    ThreadLocalMap map = getMap(t); // 获取当前线程内的map    if (map != null)        map.set(this, value); // map不为空，则以当前ThreadLocal对象为key，value为我们想要保存的值设置到map中    else        createMap(t, value); // map为空，创建一个map来保存value，当然key还是当前ThreadLocal}

　　get方法：

public T get() {    Thread t = Thread.currentThread(); // 获取当前线程    ThreadLocalMap map = getMap(t); // 获取当前线程内的map    if (map != null) {        ThreadLocalMap.Entry e = map.getEntry(this); // 以当前ThreadLocal对象为key取entry对象        if (e != null) {            @SuppressWarnings("unchecked")            T result = (T)e.value; // 获取entry中包装的值，也就是我们之前设置进来的value            return result;        }    }    return setInitialValue(); // map为空，创建一个map并给map设置一个初始值entry；或者map中没有entry，给已有的map添加一个初始值的entry}

4. TheadLocal与内存泄漏

　　 前面提到过，当线程销毁的时候，与线程绑定的相关的对象将会被GC。下面的代码展示了Thread类中的exit方法，可以看到这里将threadLocals（就是ThreadLocalMap）进行了置空，方便虚拟机对ThreadLocalMap对象进行回收。

private void exit() {    if (group != null) {        group.threadTerminated(this);        group = null;    }    /* Aggressively null out all reference fields: see bug 4006245 */    target = null;    /* Speed the release of some of these resources */    threadLocals = null; // 把ThreadLocalMap引用置空    inheritableThreadLocals = null;    inheritedAccessControlContext = null;    blocker = null;    uncaughtExceptionHandler = null;}

 　　但是在一些线程不会死亡的场景，比如在线池，因为线程不会结束，如果处理的不好，那么和线程绑定的对象就会一直存在，从而造成内存泄漏。

　　因为这里涉及到强、弱引用的知识，这里简单介绍一下：我们平常写的Object obj = new Object()中的obj就是强引用，只要还有强引用指向一个对象，这个对象不会被回收。而对于弱引用，一旦发现只被弱引用引用的对象，不管当前内存空间足够与否，这个对象都会被回收。

　　ThreadLocalMap中的Entry的key就是一个弱引用：

static class Entry extends WeakReference
     
      > {    /** The value associated with this ThreadLocal. */    Object value;    Entry(ThreadLocal
       k, Object v) {        super(k); // 创建一个弱引用的key        value = v;    }}
     

　　下图展示了Thread对象、ThreadLocal对象、ThreadLocalMap对象以及Entry对象之间的联系，其中虚线箭头表示Entry中的弱引用key指向了ThreadLocal对象：

　　Entry对象中弱引用key指向了我们的ThreadLocal对象，当我们将ThreadLocal对象的引用置为null后，就没有强用用指向它，只剩这个弱引用指向ThreadLocal对象，那么JVM会在GC的时候回收ThreadLocal对象。然而Entry对象中value引用指向的value对象还是存活的，这样就会导致value对象一直得不到回收。但是，在我们调用ThreadLocal对象的get、set、remove方法时，会将上述提到的key为nul对应的value对象进行清除，从而避免了内存泄漏。值得注意的是，如果我们在创建一个ThreadLocal对象并set了一个value对象到ThreadLocalMap，然后不再调用前面提到的get、set、remove方法中的任意一个，此时就可能会导致这个value对象不能被回收。