ThreadLocal简单学习
学习Struts2时，遇到ThreadLocal，不甚理解，所以对此作了一番学习。
ThreadLocal是什么呢？首先这并不是一个线程类，它是用来提供本地线程数据，也就是它保存的数据是线程相关的，每个线程都有一份数据副本，一个线程可以对其保存的副本进行修改，却不会影响其它的线程中的数据。这样说不易理解，比较这三种情况的数据，1、非ThreadLocal类型的静态成员数据；2、非ThreadLocal类型的非静态成员数据；3、ThreadLocal类型的静态数据。第一种情况中的数据是类类型的，所以此变量是所有线程共享的，第二种情况中的数据是实例对象相关的数据，是线程相关的，不同线程中实例数据的修改是相互不影响的。第三种虽然是静态类型的数据，但是由于是通过ThreadLocal保存的，所以还是线程相关的。由第三种类型的数据和第一种类型的数据之间的对比，可以帮助了解ThreadLocal的功能。
ThreadLocal的接口功能比较简单，常用的为get、set、remove，它们的函数签名如下
get接口public T get();
set接口public void set(T);
remove接口public void remove();
下面用一个简单的项目来说明ThreadLocal的功能。项目内容很简单，主要包括三个类TestThread、Main和TestClass
TestClass.java代码如下
import
java.util.Random;
public
class
TestClass {
private
static
int
value
=0;
public
int
nonStaticValue
;
private
static
ThreadLocal<Integer>
threadLocalValue
=
new
ThreadLocal<Integer>();
public
TestClass(){
Random rand=
new
Random();
nonStaticValue
=rand.nextInt(100);
value
++;
}
public
static
Integer getLocalThreadValue(){
return
threadLocalValue
.get();
}
public
static
void
setLocalThreadValue(Integer val){
threadLocalValue
.set(val);
}
public
static
int
getStaticValue(){
return
value
;
}
public
int
getNonStaticValue(){
return
nonStaticValue
;
}
}
TestThread.java代码如下
public
class
TestThread
extends
Thread {
private
int
id
;
TestClass
clz
;
public
TestThread(
int
id) {
super
(
"thread-"
+id);
this
.
id
= id;
System.
out
.println(
"thread in test thread constructor "
+ Thread. currentThread().getName());
}
@Override
public
void
run() {
TestClass. setLocalThreadValue( id);
clz
=
new
TestClass();
int
maxRuntime=2000;
int
step=1000;
int
totalRuntime=0;
while
(totalRuntime<maxRuntime) {
totalRuntime+=step;
System.
out
.println(Thread.currentThread().getName() +
"[non-static-value:"
+
clz
.getNonStaticValue() +
",static-value:"
+ TestClass. getStaticValue() +
",thread local value:"
+ TestClass. getLocalThreadValue() +
"]"
);
try
{
Thread. sleep(2000);
}
catch
(InterruptedException e) {
e.printStackTrace();
}
}
}
}
Main.java代码如下
public
class
Main
extends
Thread{
public
int
num
;
public
Main(String name,
int
num){
super
(name);
this
.
num
=num;
}
@Override
public
void
run(){
for
(
int
i=0;i<3;i++){
try
{
Thread. sleep(1000);
}
catch
(InterruptedException e) {
e.printStackTrace();
}
num
++;
System.
out
.println(Thread.currentThread().getName()+
"[ num = "
+
num
+
" ]"
);
}
}
public
static
void
main(String[] args) {
int
num=3;
TestThread[] threads=
new
TestThread[num];
for
(
int
i=0;i<num;i++){
threads[i]=
new
TestThread(i);
}
for
(
int
i=0;i<num;i++){
threads[i].start();
}
System.
out
.println(
"--------------------------------------+\t\r"
);
num=2;
Main[] mains=
new
Main[num];
for
(
int
i=0;i<num;i++){
mains[i]=
new
Main(
"main thread"
+i,i);
}
for
(
int
i=0;i<num;i++)
mains[i].start();
}
}
运行之后的输出结果如下
thread in test thread constructor main
thread in test thread constructor main
thread in test thread constructor main
--------------------------------------
thread-0[non-static-value:26,static-value:3,thread local value:0]
thread-1[non-static-value:49,static-value:3,thread local value:1]
thread-2[non-static-value:59,static-value:3,thread local value:2]
main thread0[ num = 1 ]
main thread1[ num = 2 ]
thread-0[non-static-value:26,static-value:3,thread local value:0]
thread-1[non-static-value:49,static-value:3,thread local value:1]
thread-2[non-static-value:59,static-value:3,thread local value:2]
main thread0[ num = 2 ]
main thread1[ num = 3 ]
main thread0[ num = 3 ]
main thread1[ num = 4 ]
看其中的输出，非静态的成员变量（私有或公有）是线程相关的，静态的类变量是多个线程共享的，而由静态的ThreadLocal对象保存的数据，依旧是线程相关的，各个线程之间的值是有区别的。
[ThreadLocal的实现原理]
要理解ThreadLocal的实现原理，需要了解ThreadLocalMap类。TThreadLocalMap有一个Entry类型的数组，每个Entry是一个<ThreadLocal,Object>的键值对，在数组中的索引由ThreadLocal对象的哈希值和当前数组的长度值减一做与操作而来，如果出现冲突，就往后查找。ThreadLocalMap类中插入键值对数据的set方法如下所示
private
void
set(ThreadLocal key, Object value) {
Entry[] tab = table;
int
len = tab.length;
int
i = key.threadLocalHashCode & (len-1); //首先获取数组索引值
/*
从计算出来的索引点开始比较，如果能找到相应的key，就更新值
*/
for
(Entry e = tab[i];
e !=
null
;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal k = e.get();
if
(k == key) {
e.value = value;
return
;
}
if
(k ==
null
) {
replaceStaleEntry(key, value, i);
return
;
}
}
tab[i] =
new
Entry(key, value); //没有找到相应的key，插入新数据
int
sz = ++size;
if
(!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
每个Thread类型的线程都有个ThreadLocalMap类型的实例变量threadlocals，用来存放与此线程相关的ThreadLocal变量。再来看ThreadLocal保存数据的set方法，代码如下
public
void
set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if
(map !=
null
)
map.set(
this
, value);
else
createMap(t, value);
}
首先获取当前的线程t，由getMap方法获取当前线程的threadLocals属性map，然后保存键值对。在保存的时候采用this对象做为键，同样在获取数据的时候，也是以this作为键来获取相应的数据。因为一个线程可能有多个由ThreadLocal对象保存的变量，采用this作为key，可以实现这样不同ThreadLocal对象之间的区分。
