深入解析Java中ThreadLocal线程类的作用和用法
ThreadLocal与线程成员变量还有区别，ThreadLocal该类提供了线程局部变量。这个局部变量与一般的成员变量不一样，ThreadLocal的变量在被多个线程使用时候，每个线程只能拿到该变量的一个副本，这是JavaAPI中的描述，通过阅读API源码，发现并非副本，副本什么概念？克隆品?或者是别的样子，太模糊。
准确的说，应该是ThreadLocal类型的变量内部的注册表（Map<Thread,T>）发生了变化，但ThreadLocal类型的变量本身的确是一个，这才是本质！
下面就做个例子：
一、标准例子
定义了MyThreadLocal类，创建它的一个对象tlt，分别给四个线程使用，结果四个线程tlt变量并没有出现共用现象，二是各用各的，这说明，四个线程使用的是tlt的副本（克隆品）。
/**
*使用了ThreadLocal的类
*/
publicclassMyThreadLocal{
//定义了一个ThreadLocal变量，用来保存int或Integer数据
privateThreadLocal<Integer>tl=newThreadLocal<Integer>(){
@Override
protectedIntegerinitialValue(){
return0;
}
};
publicIntegergetNextNum(){
//将tl的值获取后加1，并更新设置t1的值
tl.set(tl.get()+1);
returntl.get();
}
}
/**
*测试线程
*/
publicclassTestThreadextendsThread{
privateMyThreadLocaltlt=newMyThreadLocal();
publicTestThread(MyThreadLocaltlt){
this.tlt=tlt;
}
@Override
publicvoidrun(){
for(inti=0;i<3;i++){
System.out.println(Thread.currentThread().getName()+"\t"+tlt.getNextNum());
}
}
}
/**
*ThreadLocal测试
*/
publicclassTest{
publicstaticvoidmain(String[]args){
MyThreadLocaltlt=newMyThreadLocal();
Threadt1=newTestThread(tlt);
Threadt2=newTestThread(tlt);
Threadt3=newTestThread(tlt);
Threadt4=newTestThread(tlt);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
可以看出，三个线程各自独立编号，互不影响：
Thread-01 Thread-11 Thread-02 Thread-12 Thread-03 Thread-13 Thread-21 Thread-31 Thread-22 Thread-32 Thread-23 Thread-33 Processfinishedwithexitcode0
tlt对象是一个，废话tl对象也是一个，因为组合关系是一对一的。但是tl对象内部的Map随着线程的增多，会创建很多Integer对象。只是Integer和int已经通用了。所以感觉不到Integer的对象属性。
二、不用ThreadLocal
假如不用ThreadLocal，只需要将MyThreadLocal类重新定义为：
/**
*使用了ThreadLocal的类
*/
publicclassMyThreadLocal{
privateIntegert1=0;
publicIntegergetNextNum(){
returnt1=t1+1;
}
//定义了一个ThreadLocal变量，用来保存int或Integer数据
//privateThreadLocal<Integer>tl=newThreadLocal<Integer>(){
//@Override
//protectedIntegerinitialValue(){
//return0;
//}
//};
//
//publicIntegergetNextNum(){
////将tl的值获取后加1，并更新设置t1的值
//tl.set(tl.get()+1);
//returntl.get();
//}
}
然后运行测试：
Thread-21 Thread-22 Thread-14 Thread-16 Thread-33 Thread-39 Thread-310 Thread-18 Thread-07 Thread-011 Thread-012 Thread-25 Processfinishedwithexitcode0
从这里可以看出，四个线程共享了tlt变量，结果每个线程都直接修改tlt的属性。
三、自己实现个ThreadLocal
packagecom.lavasoft.test2;
importjava.util.Collections;
importjava.util.HashMap;
importjava.util.Map;
/**
*使用了ThreadLocal的类
*/
publicclassMyThreadLocal{
//定义了一个ThreadLocal变量，用来保存int或Integer数据
privatecom.lavasoft.test2.ThreadLocal<Integer>tl=newcom.lavasoft.test2.ThreadLocal<Integer>(){
@Override
protectedIntegerinitialValue(){
return0;
}
};
publicIntegergetNextNum(){
//将tl的值获取后加1，并更新设置t1的值
tl.set(tl.get()+1);
returntl.get();
}
}
classThreadLocal<T>{
privateMap<Thread,T>map=Collections.synchronizedMap(newHashMap<Thread,T>());
publicThreadLocal(){
}
protectedTinitialValue(){
returnnull;
}
publicTget(){
Threadt=Thread.currentThread();
Tobj=map.get(t);
if(obj==null&&!map.containsKey(t)){
obj=initialValue();
map.put(t,obj);
}
returnobj;
}
publicvoidset(Tvalue){
map.put(Thread.currentThread(),value);
}
publicvoidremove(){
map.remove(Thread.currentThread());
}
}
运行测试：
Thread-01 Thread-02 Thread-03 Thread-21 Thread-22 Thread-31 Thread-23 Thread-32 Thread-11 Thread-33 Thread-12 Thread-13 Processfinishedwithexitcode0
很意外，这个山寨版的ThreadLocal也同样运行很好，实现了JavaAPI中ThreadLocal的功能。
四、透过现象看本质
其实从程序角度看，tlt变量的确是一个，毫无疑问的。但是为什么打印出来的数字就互不影响呢？
是因为使用了Integer吗？-----不是。
原因是：protectedTinitialValue()和get()，因为每个线程在调用get()时候，发现Map中不存在就创建。调用它的时候，就创建了一个新变量，类型为T。每次都新建，当然各用个的互不影响了。
为了看清本质，将Integer换掉，重写部分类：
packagecom.lavasoft.test2;
importjava.util.Collections;
importjava.util.HashMap;
importjava.util.Map;
/**
*使用了ThreadLocal的类
*/
publicclassMyThreadLocal{
//定义了一个ThreadLocal变量，用来保存int或Integer数据
//privateThreadLocal<Bean>tl=newThreadLocal<Bean>(){
privatecom.lavasoft.test2.ThreadLocal<Bean>tl=newcom.lavasoft.test2.ThreadLocal<Bean>(){
@Override
protectedBeaninitialValue(){
returnnewBean();
}
};
@Override
publicStringtoString(){
return"MyThreadLocal{"+
"tl="+tl+
'}';
}
publicBeangetBean(){
returntl.get();
}
}
classThreadLocal<T>{
privateMap<Thread,T>map=Collections.synchronizedMap(newHashMap<Thread,T>());
publicThreadLocal(){
}
protectedTinitialValue(){
returnnull;
}
publicTget(){
Threadt=Thread.currentThread();
Tobj=map.get(t);
if(obj==null&&!map.containsKey(t)){
obj=initialValue();
map.put(t,obj);
}
returnobj;
}
publicvoidset(Tvalue){
map.put(Thread.currentThread(),value);
}
publicvoidremove(){
map.remove(Thread.currentThread());
}
}
packagecom.lavasoft.test2;
/**
*测试Bean
*/
publicclassBean{
privateStringid="0";
privateStringname="none";
publicBean(){
}
publicBean(Stringid,Stringname){
this.id=id;
this.name=name;
}
publicStringgetId(){
returnid;
}
publicvoidsetId(Stringid){
this.id=id;
}
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
publicStringshowinfo(){
return"Bean{"+
"id='"+id+'\''+
",name='"+name+'\''+
'}';
}
}
packagecom.lavasoft.test2;
/**
*测试线程
*/
publicclassTestThreadextendsThread{
privateMyThreadLocaltlt=newMyThreadLocal();
publicTestThread(MyThreadLocaltlt){
this.tlt=tlt;
}
@Override
publicvoidrun(){
System.out.println(">>>>>:"+tlt);
for(inti=0;i<3;i++){
System.out.println(Thread.currentThread().getName()+"\t"+tlt.getBean()+"\t"+tlt.getBean().showinfo());
}
}
}
然后运行测试：
>>>>>:MyThreadLocal{tl=com.lavasoft.test2.MyThreadLocal$1@1de3f2d}
>>>>>:MyThreadLocal{tl=com.lavasoft.test2.MyThreadLocal$1@1de3f2d}
>>>>>:MyThreadLocal{tl=com.lavasoft.test2.MyThreadLocal$1@1de3f2d}
>>>>>:MyThreadLocal{tl=com.lavasoft.test2.MyThreadLocal$1@1de3f2d}
Thread-1com.lavasoft.test2.Bean@291affBean{id='0',name='none'}
Thread-2com.lavasoft.test2.Bean@fe64b9Bean{id='0',name='none'}
Thread-3com.lavasoft.test2.Bean@186db54Bean{id='0',name='none'}
Thread-2com.lavasoft.test2.Bean@fe64b9Bean{id='0',name='none'}
Thread-2com.lavasoft.test2.Bean@fe64b9Bean{id='0',name='none'}
Thread-0com.lavasoft.test2.Bean@291affBean{id='0',name='none'}
Thread-3com.lavasoft.test2.Bean@186db54Bean{id='0',name='none'}
Thread-3com.lavasoft.test2.Bean@186db54Bean{id='0',name='none'}
Thread-1com.lavasoft.test2.Bean@291affBean{id='0',name='none'}
Thread-0com.lavasoft.test2.Bean@291affBean{id='0',name='none'}
Thread-0com.lavasoft.test2.Bean@291affBean{id='0',name='none'}
Thread-1com.lavasoft.test2.Bean@291affBean{id='0',name='none'}
Processfinishedwithexitcode0
从打印结果很清楚的看到，MyThreadLocal的tlt对象的确是一个，tlt对象里的ThreadLocal的tl对象也是一个，但是，将t1t给每个线程用的时候，线程会重新创建Bean对象加入到ThreadLocal的Map中去使用。
关于ThreadLocal的几个误区：
一、ThreadLocal是java线程的一个实现
ThreadLocal的确是和java线程有关，不过它并不是java线程的一个实现，它只是用来维护本地变量。针对每个线程，提供自己的变量版本，主要是为了避免线程冲突，每个线程维护自己的版本。彼此独立，修改不会影响到对方。
二、ThreadLocal是相对于每个session的
ThreadLocal顾名思义，是针对线程。在javaweb编程上，每个用户从开始到会话结束，都有自己的一个session标识。但是ThreadLocal并不是在会话层上。其实，Threadlocal是独立于用户session的。它是一种服务器端行为，当服务器每生成一个新的线程时，就会维护自己的ThreadLocal。
对于这个误解，个人认为应该是开发人员在本地基于一些应用服务器测试的结果。众所周知，一般的应用服务器都会维护一套线程池，也就是说，对于每次访问，并不一定就新生成一个线程。而是自己有一个线程缓存池。对于访问，先从缓存池里面找到已有的线程，如果已经用光，才去新生成新的线程。
所以，由于开发人员自己在测试时，一般只有他自己在测，这样服务器的负担很小，这样导致每次访问可能是共用同样一个线程，导致会有这样的误解：每个session有一个ThreadLocal
三、ThreadLocal是相对于每个线程的，用户每次访问会有新的ThreadLocal
理论上来说，ThreadLocal是的确是相对于每个线程，每个线程会有自己的ThreadLocal。但是上面已经讲到，一般的应用服务器都会维护一套线程池。因此，不同用户访问，可能会接受到同样的线程。因此，在做基于TheadLocal时，需要谨慎，避免出现ThreadLocal变量的缓存，导致其他线程访问到本线程变量
四、对每个用户访问，ThreadLocal可以多用
可以说，ThreadLocal是一把双刃剑，用得来的话可以起到非常好的效果。但是，ThreadLocal如果用得不好，就会跟全局变量一样。代码不能重用，不能独立测试。因为，一些本来可以重用的类，现在依赖于ThreadLocal变量。如果在其他没有ThreadLocal场合，这些类就变得不可用了。个人觉得ThreadLocal用得很好的几个应用场合，值得参考
1、存放当前session用户：quakewant的jert
2、存放一些context变量，比如webwork的ActionContext
3、存放session，比如Springhibernateorm的session