本文对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对象不能被回收。