ThreadLocal的应用与实现原理

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

本文大纲

　　1. ThreadLocal快速上手
　　2. ThreadLocal应用场景
　　3. TheadLocal set与get方法简析
　　4. TheadLocal与内存泄漏

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 -> 0
t1 -> 0 // t1线程打印0
t2 -> 1
t1 -> 2 // t1线程打印couter从0直接跳到了2，因为t0线程对counter做了修改
t2 -> 3
t1 -> 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<Integer> cntTl = new ThreadLocal<Integer>() {
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 -> 0
t2 -> 0
t1 -> 1
t2 -> 1
t1 -> 2
t2 -> 2
t1 -> 3
t2 -> 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 begin
data: test data, sql: insert into ... executed successfully
transaction commit

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

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

　　新增一个DataSource类：

public class DataSource {
private static ThreadLocal<Connection> 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 begin
connection in Dao: com.andywooh.texplore.demo.concurrency.threadlocal.Connection@15db9742
data: test data, sql: insert into ... executed successfully
connection in Service: com.andywooh.texplore.demo.concurrency.threadlocal.Connection@15db9742
transaction 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<ThreadLocal<?>> {
/** 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对象不能被回收。