深入解析Java中ThreadLocal线程类的作用和用法
threadlocal与线程成员变量还有区别，threadlocal该类提供了线程局部变量。这个局部变量与一般的成员变量不一样，threadlocal的变量在被多个线程使用时候，每个线程只能拿到该变量的一个副本，这是java api中的描述，通过阅读api源码，发现并非副本，副本什么概念？克隆品? 或者是别的样子，太模糊。
准确的说，应该是threadlocal类型的变量内部的注册表（map<thread,t>）发生了变化，但threadlocal类型的变量本身的确是一个，这才是本质！
下面就做个例子：
一、标准例子
定义了mythreadlocal类，创建它的一个对象tlt，分别给四个线程使用，结果四个线程tlt变量并没有出现共用现象，二是各用各的，这说明，四个线程使用的是tlt的副本（克隆品）。
/**
* 使用了threadlocal的类
*/
public class mythreadlocal {
//定义了一个threadlocal变量，用来保存int或integer数据
private threadlocal<integer> tl = new threadlocal<integer>() {
@override
protected integer initialvalue() {
return 0;
}
};
public integer getnextnum() {
//将tl的值获取后加1，并更新设置t1的值
tl.set(tl.get() + 1);
return tl.get();
}
}
/**
* 测试线程
*/
public class testthread extends thread {
private mythreadlocal tlt = new mythreadlocal();
public testthread(mythreadlocal tlt) {
this.tlt = tlt;
}
@override
public void run() {
for (int i = 0; i < 3; i++) {
system.out.println(thread.currentthread().getname() + "\t" + tlt.getnextnum());
}
}
}
/**
* threadlocal测试
*/
public class test {
public static void main(string[] args) {
mythreadlocal tlt = new mythreadlocal();
thread t1 = new testthread(tlt);
thread t2 = new testthread(tlt);
thread t3 = new testthread(tlt);
thread t4 = new testthread(tlt);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
可以看出，三个线程各自独立编号，互不影响：
thread-0 1 thread-1 1 thread-0 2 thread-1 2 thread-0 3 thread-1 3 thread-2 1 thread-3 1 thread-2 2 thread-3 2 thread-2 3 thread-3 3 process finished with exit code 0
tlt对象是一个，废话tl对象也是一个，因为组合关系是一对一的。但是tl对象内部的map随着线程的增多，会创建很多integer对象。只是integer和int已经通用了。所以感觉不到integer的对象属性。
二、不用threadlocal
假如不用threadlocal，只需要将mythreadlocal类重新定义为：
/**
* 使用了threadlocal的类
*/
public class mythreadlocal {
private integer t1 = 0;
public integer getnextnum(){
return t1=t1+1;
}
// 定义了一个threadlocal变量，用来保存int或integer数据
// private threadlocal<integer> tl = new threadlocal<integer>() {
// @override
// protected integer initialvalue() {
// return 0;
// }
// };
//
// public integer getnextnum() {
// //将tl的值获取后加1，并更新设置t1的值
// tl.set(tl.get() + 1);
// return tl.get();
// }
}
然后运行测试：
thread-2 1 thread-2 2 thread-1 4 thread-1 6 thread-3 3 thread-3 9 thread-3 10 thread-1 8 thread-0 7 thread-0 11 thread-0 12 thread-2 5 process finished with exit code 0
从这里可以看出，四个线程共享了tlt变量，结果每个线程都直接修改tlt的属性。
三、自己实现个threadlocal
package com.lavasoft.test2;
import java.util.collections;
import java.util.hashmap;
import java.util.map;
/**
* 使用了threadlocal的类
*/
public class mythreadlocal {
//定义了一个threadlocal变量，用来保存int或integer数据
private com.lavasoft.test2.threadlocal<integer> tl = new com.lavasoft.test2.threadlocal<integer>() {
@override
protected integer initialvalue() {
return 0;
}
};
public integer getnextnum() {
//将tl的值获取后加1，并更新设置t1的值
tl.set(tl.get() + 1);
return tl.get();
}
}
class threadlocal<t> {
private map<thread, t> map = collections.synchronizedmap(new hashmap<thread, t>());
public threadlocal() {
}
protected t initialvalue() {
return null;
}
public t get() {
thread t = thread.currentthread();
t obj = map.get(t);
if (obj == null && !map.containskey(t)) {
obj = initialvalue();
map.put(t, obj);
}
return obj;
}
public void set(t value) {
map.put(thread.currentthread(), value);
}
public void remove() {
map.remove(thread.currentthread());
}
}
运行测试：
thread-0 1 thread-0 2 thread-0 3 thread-2 1 thread-2 2 thread-3 1 thread-2 3 thread-3 2 thread-1 1 thread-3 3 thread-1 2 thread-1 3 process finished with exit code 0
很意外，这个山寨版的threadlocal也同样运行很好，实现了javaapi中threadlocal的功能。
四、透过现象看本质
其实从程序角度看，tlt变量的确是一个，毫无疑问的。但是为什么打印出来的数字就互不影响呢？
是因为使用了integer吗？-----不是。
原因是：protected t initialvalue()和get()，因为每个线程在调用get()时候，发现map中不存在就创建。调用它的时候，就创建了一个新变量，类型为t。每次都新建，当然各用个的互不影响了。
为了看清本质，将integer换掉，重写部分类：
package com.lavasoft.test2;
import java.util.collections;
import java.util.hashmap;
import java.util.map;
/**
* 使用了threadlocal的类
*/
public class mythreadlocal {
//定义了一个threadlocal变量，用来保存int或integer数据
// private threadlocal<bean> tl = new threadlocal<bean>() {
private com.lavasoft.test2.threadlocal<bean> tl = new com.lavasoft.test2.threadlocal<bean>() {
@override
protected bean initialvalue() {
return new bean();
}
};
@override
public string tostring() {
return "mythreadlocal{" +
"tl=" + tl +
'}';
}
public bean getbean() {
return tl.get();
}
}
class threadlocal<t> {
private map<thread, t> map = collections.synchronizedmap(new hashmap<thread, t>());
public threadlocal() {
}
protected t initialvalue() {
return null;
}
public t get() {
thread t = thread.currentthread();
t obj = map.get(t);
if (obj == null && !map.containskey(t)) {
obj = initialvalue();
map.put(t, obj);
}
return obj;
}
public void set(t value) {
map.put(thread.currentthread(), value);
}
public void remove() {
map.remove(thread.currentthread());
}
}
package com.lavasoft.test2;
/**
* 测试bean
*/
public class bean {
private string id = "0";
private string name = "none";
public bean() {
}
public bean(string id, string name) {
this.id = id;
this.name = name;
}
public string getid() {
return id;
}
public void setid(string id) {
this.id = id;
}
public string getname() {
return name;
}
public void setname(string name) {
this.name = name;
}
public string showinfo() {
return "bean{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
'}';
}
}
package com.lavasoft.test2;
/**
* 测试线程
*/
public class testthread extends thread {
private mythreadlocal tlt = new mythreadlocal();
public testthread(mythreadlocal tlt) {
this.tlt = tlt;
}
@override
public void run() {
system.out.println(">>>>>:" + tlt);
for (int i = 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-1 com.lavasoft.test2.bean@291aff bean{id='0', name='none'}
thread-2 com.lavasoft.test2.bean@fe64b9 bean{id='0', name='none'}
thread-3 com.lavasoft.test2.bean@186db54 bean{id='0', name='none'}
thread-2 com.lavasoft.test2.bean@fe64b9 bean{id='0', name='none'}
thread-2 com.lavasoft.test2.bean@fe64b9 bean{id='0', name='none'}
thread-0 com.lavasoft.test2.bean@291aff bean{id='0', name='none'}
thread-3 com.lavasoft.test2.bean@186db54 bean{id='0', name='none'}
thread-3 com.lavasoft.test2.bean@186db54 bean{id='0', name='none'}
thread-1 com.lavasoft.test2.bean@291aff bean{id='0', name='none'}
thread-0 com.lavasoft.test2.bean@291aff bean{id='0', name='none'}
thread-0 com.lavasoft.test2.bean@291aff bean{id='0', name='none'}
thread-1 com.lavasoft.test2.bean@291aff bean{id='0', name='none'}
process finished with exit code 0
从打印结果很清楚的看到，mythreadlocal的tlt对象的确是一个，tlt对象里的threadlocal的tl对象也是一个，但是，将t1t给每个线程用的时候，线程会重新创建bean对象加入到threadlocal的map中去使用。
关于threadlocal的几个误区：
一、threadlocal是java线程的一个实现
threadlocal的确是和java线程有关，不过它并不是java线程的一个实现，它只是用来维护本地变量。针对每个线程，提供自己的变量版本，主要是为了避免线程冲突，每个线程维护自己的版本。彼此独立，修改不会影响到对方。
二、threadlocal是相对于每个session的
threadlocal顾名思义，是针对线程。在java web编程上，每个用户从开始到会话结束，都有自己的一个session标识。但是threadlocal并不是在会话层上。其实，threadlocal是独立于用户session的。它是一种服务器端行为，当服务器每生成一个新的线程时，就会维护自己的threadlocal。
对于这个误解，个人认为应该是开发人员在本地基于一些应用服务器测试的结果。众所周知，一般的应用服务器都会维护一套线程池，也就是说，对于每次访问，并不一定就新生成一个线程。而是自己有一个线程缓存池。对于访问，先从缓存池里面找到已有的线程，如果已经用光，才去新生成新的线程。
所以，由于开发人员自己在测试时，一般只有他自己在测，这样服务器的负担很小，这样导致每次访问可能是共用同样一个线程，导致会有这样的误解：每个session有一个threadlocal
三、threadlocal是相对于每个线程的，用户每次访问会有新的threadlocal
理论上来说，threadlocal是的确是相对于每个线程，每个线程会有自己的threadlocal。但是上面已经讲到，一般的应用服务器都会维护一套线程池。因此，不同用户访问，可能会接受到同样的线程。因此，在做基于theadlocal时，需要谨慎，避免出现threadlocal变量的缓存，导致其他线程访问到本线程变量
四、对每个用户访问，threadlocal可以多用
可以说，threadlocal是一把双刃剑，用得来的话可以起到非常好的效果。但是，threadlocal如果用得不好，就会跟全局变量一样。代码不能重用，不能独立测试。因为，一些本来可以重用的类，现在依赖于threadlocal变量。如果在其他没有threadlocal场合，这些类就变得不可用了。个人觉得threadlocal用得很好的几个应用场合，值得参考
1、存放当前session用户：quake want的jert
2、存放一些context变量，比如webwork的actioncontext
3、存放session，比如spring hibernate orm的session