《Java动手撸源码》线程上下文设计模式（一文全解ThreadLocal）
文章目录
前言
线程上下文设计模式，估计很多人都没听过，这一概念来自于汪文君老师的书《Java高并发编程详解》多线程架构设计的第21章，简单解释，上下文就是贯穿整个系统或者阶段生命周期的对象，其中包含着系统全局的一些信息，比如登录的用户信息、账号信息，以及在程序每一个阶段运行时的数据。单例设计模式中的单例对象其实也是一种上下文对象，因为它贯穿了整个程序运行的生命周期。
Netty里面用到的职责链设计模式，也是线程上下文设计模式的一个形象的应用，Netty的收发数据，入站和出站，将所有的Handler对象通过双向链表的方式连接起来，如果Netty收到消息时，会在双向链表里面遍历所有的handler节点，判断该节点是否是InboundHandler,如果是的话就交由该节点进行处理，然后继续传递给下一个节点。职责链从头到尾传递ChannelHandlerContext对象，这里的ChannelHandlerContext对象就是线程上下文对象。Netty的责任链如下图所示：
本作者维护了一个仓库，名称叫Thread，打算在这个仓库里面手写实现Java多线程的一些经典技术，欢迎大家的star，本博文的代码已经上传到了该仓库，在com.thread.threadcontext包下。
链接: 仓库地址。欢迎大家的star，您的star是我继续下去的动力。
一、ThreadLocal介绍
ThreadLocal我们都用过，只有两个关键方法，分别是Get和Set，一开始ThreadLocal里面没有当前线程存储的对象，那么就使用Set方法创建当前线程对应的对象，然后通过Get方法获得。因为要建立当前线程到对象的映射，所以他的使用场景有以下几种：
1、对象跨层传递的时候
2、线程间的数据隔离
3、进行事务操作，用于存储线程事务信息，保证一个线程下执行多个操作获取的是同一个Connetion对象。
比如JdbcUtil的实现如下：
package com.backstage.utils;
import java.io.IOException;
import java.io.Reader;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
public class JdbcUtil {
private static ThreadLocal<SqlSession> threadSession = new ThreadLocal<SqlSession>() ;
private static SqlSession sqlsession= null;
public static SqlSession getThreadLocalSqlSession(){
SqlSession sqlSession = threadSession.get();
if(sqlSession!=null) {
return sqlSession;
}else {
SqlSessionFactory sqlsessionFactory = null;
try {
Reader reader = Resources.getResourceAsReader("conf.xml");
sqlsessionFactory= new SqlSessionFactoryBuilder().build(reader);
reader.close();
} catch(IOException ignore) {
System.out.println("读取mybatis配置文件失败");
ignore.printStackTrace();
}
threadSession.set(sqlSession);
return sqlsessionFactory.openSession();
}
}
public static SqlSession getSqlSession(){
if(sqlsession==null) {
SqlSessionFactory sqlsessionFactory = null;
try {
Reader reader = Resources.getResourceAsReader("conf.xml");
sqlsessionFactory= new SqlSessionFactoryBuilder().build(reader);
reader.close();
} catch(IOException ignore) {
System.out.println("读取mybatis配置文件失败");
ignore.printStackTrace();
}
sqlsession = sqlsessionFactory.openSession();
}
return sqlsession;
}
}
//转账操作
jianqian();
jiaqian();
以上的转账业务，应该是公用一个connection对象，所以为了为了多个操作之间共享对象，就使用ThreadLocal.
二、Coding实现简易版本
经过分析发现，ThreadLocal的结构是内置一个Map集合，里面存储着Thead与对象之间的映射关系，通过Get获取当前线程对应的对象，通过Set方法将对象与当前线程建立映射。比较easy，直接上code。
package com.thread.threadlocal;
import java.util.HashMap;
public class ThreadLocalSample<T> {
//核心存储容器，ThreadLocal需要考虑到多个线程并发，所以要考虑线程安全问题。
final private HashMap<Thread, T> threadLocalMap = new HashMap<Thread, T>();
public void set(T t) {
synchronized (threadLocalMap) {
Thread key = Thread.currentThread();
threadLocalMap.put(key, t);
}
}
public T get() {
synchronized (threadLocalMap) {
Thread currentThread = Thread.currentThread();
return threadLocalMap.get(currentThread);
}
}
}
三、查看API源码
3.1 ThreadLocal类图
代码如下（示例）：
//自定义Entry对象，继承WeakReference类
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
//第一次调用Get的时候，当前线程没有存储值，所以就调用initialValue进行初始化。
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;
}
//删除当前线程对应的值
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
3.1 API解析
Java的API考虑到一个Thread可能有多个ThreadLocal，所以在Thread类里面定义了ThreadLocalMap对象，用来存储多个ThreadLocalMap与Value的关系。
class Thread implements Runnable {
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
///*******************************
}
结构如下图所示，其中Map的Entry对象是WeakReference，弱引用：
3.2.1 Set方法
观察ThreadLocal的Set方法会发现，首先是调用getMap函数获取当前当前线程的ThreadLocalMap集合，然后根据当前的ThreadLocal对象与对应的值建立映射存入Map；如果集合目前为空，就先创建ThreadLocalMap对象，存入第一条记录。
public void set(T value) {
Thread t = Thread.currentThread();
///获取当前线程的ThreadLocalMap
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
3.2.2 Get方法
Get方法的实现，首先也是先调用getMap方法获取当前Thread存储的ThreadLocalMap对象，然后从map对象里面取数据，如果当前没有数据，就先调用setInitialValue函数获取默认值。initialValue函数是可以重写的，用来给ThreadLocal里面存储的value值设置初始值。
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
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;
}
3.2.3 ThreadLocalMap
通过查看自定义的ThreadLocalMap类，我们看到，它实现了动态扩容以及删除无效数据的操作，比如getEntry方法，如果发现当前ThreadLocal存储的值是null，那么就将该映射从Map中删除。最终执行删除的方法是expungeStaleEntry。
private Entry getEntry(ThreadLocal<?> key) {
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
if (e != null && e.get() == key)
return e;
else
return getEntryAfterMiss(key, i, e);
}
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
while (e != null) {
ThreadLocal<?> k = e.get();
if (k == key)
return e;
if (k == null)
expungeStaleEntry(i);
else
i = nextIndex(i, len);
e = tab[i];
}
return null;
}
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// expunge entry at staleSlot
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
// Rehash until we encounter null
Entry e;
int i;
for (i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
if (k == null) {
e.value = null;
tab[i] = null;
size--;
} else {
int h = k.threadLocalHashCode & (len - 1);
if (h != i) {
tab[i] = null;
// Unlike Knuth 6.4 Algorithm R, we must scan until
// null because multiple entries could have been stale.
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}
3.2.4、弱引用Entry
ThreadLocal的第一个改进就是，使用弱引用的Entry对象，只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。
一般在弱引用的同时，这个对象可能也被强引用。当不存在外部强引用时，Entry势必会被GC回收
四、内存泄漏问题
1、内存泄漏是什么
内存泄漏（Memory Leak）是指程序中已动态分配的堆内存由于某种原因程序未释放或无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。
当某个线程结束了生命周期，但是Thread的实例和所要存储的数据还存在于contexts中，随着运行时间的不断增大，在contexts中就会残留很多的thread实例以及被保存的数据。
尤其是早期ThreadLocal的实现使用HashMap实现的，我第三章也是用HashMap实现的，存在一定的弊端，HashMap是强引用，当内存空间不足时，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题。
通过上面，所知道，ThreadLocalMap使用ThreadLocal的弱引用作为key，如果一个ThreadLocal不存在外部强引用时，Key(ThreadLocal)势必会被GC回收，这样就会导致ThreadLocalMap中key为null， 而value还存在一条强引用链：Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value，导致value对应的Object一直无法被回收，产生内存泄露。只有thead线程退出以后,value的强引用链条才会断掉。而如果线程一直不退出，就会造成内存泄漏，因为ThreadLocal的生命周期和线程是一样的，线程不死，value的强引用一直存在着。
2、那为啥非得用弱引用的？？
因为当ThreadLocalMap的key为强引用，并且回收ThreadLocal时，因为ThreadLocalMap还持有ThreadLocal的强引用，如果没有手动删除，ThreadLocal将不会被回收，导致Entry内存泄漏。
3、弱引用的处理办法
当ThreadLocalMap的key为弱引用回收ThreadLocal时，由于ThreadLocalMap持有ThreadLocal的弱引用，即使没有手动删除，ThreadLocal也会被回收。当key为null，在下一次ThreadLocalMap调用set(),get()，remove()方法的时候会被清除value值。具体方法看expungeStaleEntry。但是如果使用了ThreadLocal的get或set方法后发生GC，或者此后不调用get、set或remove方法，为null的value就不会被清除，从而造成内存泄漏。所以一定要手动进行remove。这才是解决内存泄漏的关键！！！！
4、总结
由于Thread中包含变量ThreadLocalMap，因此ThreadLocalMap与Thread的生命周期是一样长，如果都没有手动删除对应key，都会导致内存泄漏。使用弱引用可以多一层保障：弱引用ThreadLocal不会内存泄漏，对应的value在下一次ThreadLocalMap调用set(),get(),remove()的时候会被清除。因此，ThreadLocal内存泄漏的根源是：由于ThreadLocalMap的生命周期跟Thread一样长，如果没有手动删除对应key就会导致内存泄漏，而不是因为弱引用。所以要养成及时remove的习惯。
五、InheritableThreadLocal
Java中允许子线程继承父类的ThreadLocal，如上面类图所示，InheritableThreadLocal继承ThreadLocal，并且实现了childValue等方法。代码如下：
public class InheritableThreadLocal<T> extends ThreadLocal<T> {
protected T childValue(T parentValue) {
return parentValue;
}
ThreadLocalMap getMap(Thread t) {
return t.inheritableThreadLocals;
}
void createMap(Thread t, T firstValue) {
t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
}
}
我们查看Thread的源码，发现Thread类里面同样定一个了一个inheritableThreadLocals,即是可以集成的ThreadLocalMap。然后通过查看Threa的init函数，发现子线程在创建过程中会自动的继承父类的inheritableThreadLocals。
class Thread implements Runnable {
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
///*******************************
}
private void init(ThreadGroup g, Runnable target, String name,
long stackSize, AccessControlContext acc,
boolean inheritThreadLocals) {
-----------------------------------------------------
if (inheritThreadLocals && parent.inheritableThreadLocals != null)
this.inheritableThreadLocals =
ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
-----------------------------------------------------
}
static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
return new ThreadLocalMap(parentMap);
}
private ThreadLocalMap(ThreadLocalMap parentMap) {
Entry[] parentTable = parentMap.table;
int len = parentTable.length;
setThreshold(len);
table = new Entry[len];
for (int j = 0; j < len; j++) {
Entry e = parentTable[j];
if (e != null) {
@SuppressWarnings("unchecked")
ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
if (key != null) {
Object value = key.childValue(e.value);
Entry c = new Entry(key, value);
int h = key.threadLocalHashCode & (len - 1);
while (table[h] != null)
h = nextIndex(h, len);
table[h] = c;
size++;
}
}
}
}
总结
ThreadLocal是线程上下文设计模式中一个非常有用的技术点，简易版的实现上也很简单，但是由于ThreadLocal的生命周期和线程的生命周期是一致的，而且不手动释放相应的key，那么就会造成内存泄漏问题，Jdk新版本的ThreadLocal使用了弱引用WeakReference，一定程度上缓解了内存泄漏问题，但是没有根本上解决，因为value是强引用，会出现Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value的强引用链，导致内存泄漏，所以使用ThreadLocal之后最好手动remove。这才是解决内存泄漏问题的关键所在。
428
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
