一、基础概念
ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量，使线程之间相互独立互不影响
1.1 同步机制的比较
对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。
前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。
Threadlocal的最大作用就是 代替同步锁，提高相关性能。
与volatile关键字的对比
在并发编程中，多个线程访问同一个变量，可能读到另一个线程修改后的值，也可能不是修改后的值。
所以volatile保证我读到的是最新的值，而ThreadLocal保证我读到的是不会被其他线程影响到的值。
1.2 使用场景（多用于全局变量）
1.日志统计：计算接口调用耗时时，缓存当前的开始时间，和请求id
2.读写分离时，缓存读写标志。
3.数据库连接管理
-
private
static ThreadLocal<Connection> connectionHolder=
new
ThreadLocal<Connection>() {
-
public Connection
initialValue
() {
-
return DriverManager.getConnection(DB_URL);
-
}
-
};
-
-
public
static Connection
getConnection
() {
-
return connectionHolder.get();
-
}
4.Session管理
-
private
static
final
ThreadLocal
threadSession
=
new
ThreadLocal();
-
-
public
static Session
getSession
()
throws InfrastructureException {
-
Session
s
= (Session) threadSession.get();
-
try {
-
if (s ==
null) {
-
s = getSessionFactory().openSession();
-
threadSession.set(s);
-
}
-
}
catch (HibernateException ex) {
-
throw
new
InfrastructureException(ex);
-
}
-
return s;
-
}
5.调用链（参数传递）
如在公司设置的适配器功能
设置cxGoodsPurchasesFromDubboList
-
@Slf4j
-
@Component
-
public
class
CxGoodsPurchasesDtoAdapter
implements
CxGoodsPurchasesDtoTarget {
-
-
private
final ThreadLocal<List<CxGoodsPurchasesFromDubbo>> adaptResultContext =
new
ThreadLocal<>();
-
-
@Resource
-
private CxCommonBO cxCommonBO;
-
-
@Resource
-
private CxMartRService cxMartRService;
-
-
private List<CxGoodsPurchasesFromDubbo> cxGoodsPurchasesFromDubboList;
-
-
@Override
-
public
void
adaptFromDubbo
(List<CxGoodsPurchasesInfo> req) {
-
try {
-
log.info(
"=============start invoke method CxGoodsPurchasesDtoAdapter adaptFromDubbo,param={}", JsonUtils.toJsonTrim(req));
-
if (CollectionUtils.isEmpty(req)) {
-
return;
-
}
-
cxGoodsPurchasesFromDubboList =
new
ArrayList<>();
-
for (CxGoodsPurchasesInfo cxGoodsPurchasesInfo : req) {
-
CxGoodsPurchasesFromDubbo
cxGoodsPurchasesFromDubbo
=
new
CxGoodsPurchasesFromDubbo();
-
cxGoodsPurchasesFromDubbo.setGoodsCode(cxGoodsPurchasesInfo.getGoodsCode());
-
cxGoodsPurchasesFromDubbo.setGoodsName(cxGoodsPurchasesInfo.getGoodsName());
-
cxGoodsPurchasesFromDubbo.setSkuId(cxGoodsPurchasesInfo.getSkuId());
-
cxGoodsPurchasesFromDubbo.setBarCode(cxGoodsPurchasesInfo.getBarCode());
-
cxGoodsPurchasesFromDubbo.setBaseUnit(cxGoodsPurchasesInfo.getBaseUnit());
-
cxGoodsPurchasesFromDubbo.setTaxCode(cxGoodsPurchasesInfo.getTaxCode());
-
cxGoodsPurchasesFromDubbo.setTaxRatio(cxGoodsPurchasesInfo.getTaxRatio());
-
cxGoodsPurchasesFromDubbo.setWeight(cxGoodsPurchasesInfo.getWeight());
-
-
cxGoodsPurchasesFromDubbo.setWareTypeCode(cxGoodsPurchasesInfo.getWareTypeCode());
-
cxGoodsPurchasesFromDubbo.setSource(cxGoodsPurchasesInfo.getSource());
-
cxGoodsPurchasesFromDubbo.setSupplierCode(cxGoodsPurchasesInfo.getSupplierCode());
-
List<CatFrameworkLevel> catFrameworkLevels = cxGoodsPurchasesInfo.getCatFrameworkLevels();
-
setCategoryCode(cxGoodsPurchasesFromDubbo, catFrameworkLevels);
-
setCxGoodsMdl(cxGoodsPurchasesFromDubbo, cxGoodsPurchasesInfo);
-
cxGoodsPurchasesFromDubboList.add(cxGoodsPurchasesFromDubbo);
-
}
-
adaptResultContext.set(cxGoodsPurchasesFromDubboList);
-
log.info(
"adaptResultContext set success,currentThread={}", Thread.currentThread());
-
}
catch (Exception e) {
-
log.error(
"invoke method CxGoodsPurchasesDtoAdapter adaptFromDubbo occur error", e);
-
}
-
}
取cxGoodsPurchasesFromDubboList
-
@CxRouter
-
@Slf4j
-
public
class
CxGoodsHandler
implements
Handler {
-
-
@Resource
-
protected CxGoodsRService cxGoodsRService;
-
@Resource
-
private CxPurchasesConfigService cxPurchasesConfigService;
-
@Resource
-
private CxCommonBO cxCommonBO;
-
-
@Resource
-
private CxGoodsPurchasesDtoAdapter cxGoodsPurchasesDtoAdapter;
-
-
@Resource
-
private CxGoodsFallbackLogsService cxGoodsFallbackLogsService;
-
-
@Override
-
public
void
handle
(List<CxGoodsPurchasesDTO> datas) {
-
-
List<CxGoodsPurchasesFromDubbo> cxGoodsPurchasesFromDubboList = cxGoodsPurchasesDtoAdapter.getAdaptResult();
-
if (CxCollectionUtils.isEmpty(cxGoodsPurchasesFromDubboList)) {
-
log.info(
"cxGoodsPurchasesDtoAdapter getAdaptResult is Empty,start invoke method doInvokeGoodsInterface");
-
doInvokeGoodsInterface(datas);
-
return;
-
}
-
doSetGoodsFromDubbo(datas, cxGoodsPurchasesFromDubboList);
-
log.info(
"=============after invoke method CxGoodsHandler handle,result={}", JsonUtils.toJsonTrim(datas));
-
-
}
二、底层原理分析
2.1 java.lang.Thread#threadLocals属性
每一个Thread 对象均含有一个ThreadLocalMap 类型的成员变量threadLocals ，它存储本线程中所有ThreadLocal对象及其对应的值。
Thread类有一个核心属性threadLocals，这个threadLocals就是用来存储当前线程变量和对应副本值的映射关系的。即让threadLocals引用指向key为threadLocal，value为当前线程的值。
其中键值为当前ThreadLocal变量(该变量与当前线程有关但不是当前线程值)，value为变量副本（即T类型的变量的值）。源码如下：
-
/* ThreadLocal values pertaining to this thread. This map is maintained
-
* by the ThreadLocal class. */
-
ThreadLocal.
ThreadLocalMap
threadLocals
=
null;
注意：是Thread类有一个threadLocals变量，而不是ThreadLocal类有threadLocals变量（之前理解搞反了）
2.2 java.lang.ThreadLocal.ThreadLocalMap
-
/**
-
* ThreadLocalMap is a customized hash map suitable only for
-
* maintaining thread local values. No operations are exported
-
* outside of the ThreadLocal class. The class is package private to
-
* allow declaration of fields in class Thread. To help deal with
-
* very large and long-lived usages, the hash table entries use
-
* WeakReferences for keys. However, since reference queues are not
-
* used, stale entries are guaranteed to be removed only when
-
* the table starts running out of space.
-
*/
-
static
class
ThreadLocalMap {
-
-
/**
-
* The entries in this hash map extend WeakReference, using
-
* its main ref field as the key (which is always a
-
* ThreadLocal object). Note that null keys (i.e. entry.get()
-
* == null) mean that the key is no longer referenced, so the
-
* entry can be expunged from table. Such entries are referred to
-
* as "stale entries" in the code that follows.
-
*/
-
static
class
Entry
extends
WeakReference<ThreadLocal<?>> {
-
/** The value associated with this ThreadLocal. */
-
Object value;
-
-
Entry(ThreadLocal<?> k, Object v) {
-
super(k);
-
value = v;
-
}
-
}
ThreadLocalMap 由一个个Entry 对象构成。
Entry 继承自WeakReference<ThreadLocal<?>> ，一个Entry 由ThreadLocal 对象和Object 构
成。由此可见， Entry 的key是ThreadLocal对象，并且是一个弱引用。当没指向key的强引用后，该key就会被垃圾收集器回收，而value为变量值。
2.3 ThreadLocal是如何为每个线程创建变量的副本的
初始时，在Thread里面，threadLocals为空，当通过ThreadLocal变量调用get()方法或者set()方法，就会对Thread类中的threadLocals进行初始化，并且以当前ThreadLocal变量为键值，以ThreadLocal要保存的副本变量为value，存到threadLocals。
然后在当前线程里面，如果要使用副本变量，就可以通过get方法在threadLocals里面查找。
注意：
1.在进行get之前，必须先set，否则会报空指针异常；如果想在get之前不需要调用set就能正常访问的话，必须重写initialValue()方法。
2.3.1 set方法
当执行set方法时，ThreadLocal首先会获取当前线程对象，然后获取当前线程的ThreadLocalMap类型对象。再以当前ThreadLocal对象为key，将值存储进ThreadLocalMap类型对象中。
set方法主要就是初始化threadLocals，不同的线程会new出不同的ThreadLocalMap
-
/**
-
* Sets the current thread's copy of this thread-local variable
-
* to the specified value. Most subclasses will have no need to
-
* override this method, relying solely on the {@link #initialValue}
-
* method to set the values of thread-locals.
-
*
-
* @param value the value to be stored in the current thread's copy of
-
* this thread-local.
-
*/
-
public
void
set
(T value) {
-
Thread
t
= Thread.currentThread();
-
ThreadLocalMap
map
= getMap(t);
-
if (map !=
null)
-
map.set(
this, value);
-
else
-
createMap(t, value);
-
}
可以看到，set(T value)方法为每个Thread对象都创建了一个ThreadLocalMap，并且将value放入ThreadLocalMap中，ThreadLocalMap作为Thread对象的成员变量保存。
2.3.2 get()方法源码分析：
get方法执行过程类似。ThreadLocal首先会获取当前线程对象，然后获取当前线程的ThreadLocalMap对象。再以当前ThreadLocal对象为key，获取对应的value。
-
/**
-
* Returns the value in the current thread's copy of this
-
* thread-local variable. If the variable has no value for the
-
* current thread, it is first initialized to the value returned
-
* by an invocation of the {@link #initialValue} method.
-
*
-
* @return the current thread's value of this thread-local
-
*/
-
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();
-
}
-
-
/**
-
* 获取当前ThreadLocalMap
-
* Get the map associated with a ThreadLocal. Overridden in
-
* InheritableThreadLocal.
-
*
-
* @param t the current thread
-
* @return the map
-
*/
-
ThreadLocalMap
getMap
(Thread t) {
-
return t.threadLocals;
-
}
-
-
-
/**
-
* 初始化threadLocals
-
* Create the map associated with a ThreadLocal. Overridden in
-
* InheritableThreadLocal.
-
*
-
* @param t the current thread
-
* @param firstValue value for the initial entry of the map
-
*/
-
void
createMap
(Thread t, T firstValue) {
-
t.threadLocals =
new
ThreadLocalMap(
this, firstValue);
-
}
-
-
-
-
/**
-
* Variant of set() to establish initialValue. Used instead
-
* of set() in case user has overridden the set() method.
-
*
-
* @return the initial value
-
*/
-
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;
-
}
-
-
-
-
-
-
-
/**
-
* 初始值为空，若想不为空，则需客户端重写
-
* Returns the current thread's "initial value" for this
-
* thread-local variable. This method will be invoked the first
-
* time a thread accesses the variable with the {@link #get}
-
* method, unless the thread previously invoked the {@link #set}
-
* method, in which case the {@code initialValue} method will not
-
* be invoked for the thread. Normally, this method is invoked at
-
* most once per thread, but it may be invoked again in case of
-
* subsequent invocations of {@link #remove} followed by {@link #get}.
-
*
-
* <p>This implementation simply returns {@code null}; if the
-
* programmer desires thread-local variables to have an initial
-
* value other than {@code null}, {@code ThreadLocal} must be
-
* subclassed, and this method overridden. Typically, an
-
* anonymous inner class will be used.
-
*
-
* @return the initial value for this thread-local
-
*/
-
protected T
initialValue
() {
-
return
null;
-
}
我们发现如果没有先set的话，即在map中查找不到对应的存储，则会通过调用setInitialValue方法返回i，而在setInitialValue方法中，有一个语句是T value = initialValue()，
而默认情况下，initialValue方法返回的是null。
重写逻辑可以参考如下：
-
ThreadLocal
<Long
> longLocal
= new ThreadLocal
<Long
>(){
-
protected Long initialValue() {
-
return Thread.currentThread().getId();
-
};
-
};
-
ThreadLocal
<
String
> stringLocal
= new ThreadLocal
<
String
>(){;
-
protected
String initialValue() {
-
return Thread.currentThread().getName();
-
};
-
};
2.3.3 ThreadLocal的remove方法
-
/**
-
* Removes the current thread's value for this thread-local
-
* variable. If this thread-local variable is subsequently
-
* {@linkplain #get read} by the current thread, its value will be
-
* reinitialized by invoking its {@link #initialValue} method,
-
* unless its value is {@linkplain #set set} by the current thread
-
* in the interim. This may result in multiple invocations of the
-
* {@code initialValue} method in the current thread.
-
*
-
* @since 1.5
-
*/
-
public
void
remove
() {
-
ThreadLocalMap
m
= getMap(Thread.currentThread());
-
if (m !=
null)
-
m.remove(
this);
-
}
-
-
-
-
/**
-
* Remove the entry for key.
-
*/
-
private
void
remove
(ThreadLocal<?> key) {
-
Entry[] tab = table;
-
int
len
= tab.length;
-
int
i
= key.threadLocalHashCode & (len-
1);
-
for (
Entry
e
= tab[i];
-
e !=
null;
-
e = tab[i = nextIndex(i, len)]) {
-
if (e.get() == key) {
-
e.clear();
-
expungeStaleEntry(i);
-
return;
-
}
-
}
-
}
ThreadLocal的remove()方法会先将Entry中对key的弱引用断开，设置为null，然后再清除对应的key为null的value。
2.4 ThreadLocal与内存泄漏
2.4.1内存泄漏的原因
ThreadLocalMap使用ThreadLocal的弱引用作为key，如果一个ThreadLocal不存在外部强引用时，Key(ThreadLocal)势必会被GC回收，这样就会导致ThreadLocalMap中key为null， 而value还存在着强引用，只有thead线程退出以后,value的强引用链条才会断掉，但如果当前线程再迟迟不结束的话(如用线程池进行管理的dubbo线程等)，这些key为null的Entry的value就会一直存在一条强引用链（红色链条）
下图可以更直接的表示。其中虚线表示弱引用
下图虚线表示弱引用。ThreadLocal对象被GC回收了，那么key变成了null。Map又是通过key拿到的value的对象。
所以，GC在回收了key所占内存后，没法访问到value的值，因为需要通过key才能访问到value对象。另外，如图所示的引用链：CurrentThread -- Map -- Entry -- value ，所以，在当前线程没有被回收的情况下，value所占内存也不会被回收。所以可能会造成了内存溢出。
参考：
1.ThreadLocal内存泄露 ThreadLocal内存泄露_小大宇的博客-CSDN博客_threadlocal 泄露
ThreadLocal原理及内存泄露预防_puppylpg的博客-CSDN博客_threadlocal内存泄漏
ThreadLocal内存溢出问题_幽夜落雨的博客-CSDN博客
2.4.2 如何防止内存泄漏
因为上述的原因，在ThreadLocal这个类的get（）、set（）、remove（）方法，均有实现回收 key 为 null 的 Entry 的 value所占的内存。
所以，为了防止内存泄露（没法访问到的内存），在不会再用ThreadLocal的线程任务末尾，调用一次 上述三个方法的其中一个即可，一般使用remove。
思考
1.threadLocal是如何保证线程之间的值，互相独立的？
由于每一条线程均含有各自私有的ThreadLocalMap容器，这些容器相互独立互不影响，因此不会存在线程安全性问题，从而也无需使用同步机制来保证多条线程访问容器的互斥性。
ThreadLocal对象每次调用set方法，都是设置的是当前线程的threadLocals变量的值。
调用get方法时也是获取当前线程的threadLocals变量。
即ThreadLocalMap对象不一样，且在set/get方法时都按照当前线程设置和获取的。比如线程1的threadLocals变量和线程2threadLocals变量肯定是不同的。
2.ThreadLocal是否会造成内存溢出？
我认为很难造成内存溢出，因为ThreadLocalMap中的Entry继承了WeakReferenc。但可能造成内存泄露。
3.如果key 使用强引用会怎样？
当threadLocalMap的key为强引用回收ThreadLocal时，因为ThreadLocalMap还持有ThreadLocal的强引用，如果没有手动删除或线程没有退出（被线程池管理），ThreadLocal不会被回收，那么将一直占用内存，同样可能导致内存泄漏。并且当前线程很有可能取到之前同名线程的值，造成数据紊乱。
所以使用强引用并不会回收掉ThreadLocal的内存，反而会影响线程之间的相互隔离
@see 14.Java并发编程：深入剖析ThreadLocalhttp://www.cnblogs.com/dolphin0520/p/3920407.html
@see ThreadLocal源码解读http://www.cnblogs.com/micrari/p/6790229.html
4.duboo中使用Threadlocal
首先ThreadLocal是跟着线程走的，而不管是dubbo或者其他的rpc框架或者Springmvc都有个特点：使用的是线程池模型，当线程执行任务结束之后会回到线程池，这时如果在回到线程池之前ThreadLocal没有被清理，当下一次请求拿到这个线程的时候还能读取到之前没有被清理的ThreadLocal的数据，这样显然不是我们想要的结果了。
在 Dubbo 中使用 ThreadLocal ，如果采用默认的设置，每次 Dubbo 调用结束，Dubbo 处理响应线程并不会被销毁， 而是归还到线程池中。而从 ThreadLocal 源码可以看出，每次我们设置的值其实会存在位于 Thread 中 ThreadLocalMap 变量中。
这就导致，下次如果 Dubbo 处理响应恰好继续使用到这个线程，该线程就能调用到上次响应中设置在 ThreadLocal 设置的值。这会导致业务上异常。其实并不止在 Dubbo 中，该案例还会发生在 web项目中，只要相关使用线程池的，都有可能发生。
442
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
