快速了解Java中ThreadLocal类

最近看android framework层代码，看到了threadlocal这个类，有点儿陌生，就翻了各种相关博客一一拜读；自己随后又研究了一遍源码，发现自己的理解较之前阅读的博文有不同之处，所以决定自己写篇文章说说自己的理解，希望可以起到以下作用：
– 可以疏通研究结果，加深自己的理解；
– 可以起到抛砖引玉的作用，帮助感兴趣的同学疏通思路；
– 分享学习经历，同大家一起交流和学习。

一、 threadlocal 是什么

threadlocal 是java类库的基础类，在包java.lang下面；

官方的解释是这样的：
implements a thread-local storage, that is, a variable for which each thread has its own value. all threads share the same threadlocal object, but each sees a different value when accessing it, and changes made by one thread do not affect the other threads. the implementation supports null values.

大致意思是：
可以实现线程的本地存储机制，threadlocal变量是一个不同线程可以拥有不同值的变量。所有的线程可以共享同一个threadlocal对象，但是不同线程访问的时候可以取得不同的值，而且任意一个线程对它的改变不会影响其他线程。类实现是支持null值的（可以在set和get方法传递和访问null值）。

概括来讲有三个特性：

– 不同线程访问时取得不同的值
– 任意线程对它的改变不影响其他线程
– 支持null

下面分别对这些特性进行实例验证，首先定义一个test类，在此类中我们鉴证上边所提到的三个特性。类定义如下：

test.java

public class test{

//定义threadlocal

private static threadlocal name;

public static void main(string[] args) throws exception{

name = new threadlocal();

//define thread a

thread a = new thread(){

public void run(){

system.out.println("before invoke set,value is:"+name.get());

name.set(“thread a”);

system.out.println("after invoke set, value is:"+name.get());

}

;

//define thread b

thread b = new thread(){

public void run(){

system.out.println("before invoke set,value is :"+name.get());

name.set(“thread b”);

system.out.println("after invoke set,value is :"+name.get());

}

;

// not invoke set, print the value is null

system.out.println(name.get());

// invoke set to fill a value

name.set(“thread main”);

// start thread a

a.start();

a.join();

// print the value after changed the value by thread a

system.out.println(name.get());

// start thread b

b.start();

b.join();

// print the value after changed the value by thread b

system.out.println(name.get())

}

代码分析：

从定义中我们可以看到只声明了一个threadlocal对象，其他三个线程（主线程、thread a和thread b）共享同一个对象；然后，在不同的线程中修改对象的值和在不同的线程中访问对象的值，并在控制台输出查看结果。

看结果：

从控制台输出结果可以看到里边有三个null的输出，这个是因为在输出前没有对对象进行赋值，验证了支持null的特点；再者，还可以发现在每个线程我都对对象的值做了修改，但是在其他线程访问对象时并不是修改后的值，而是访问线程本地的值；这样也验证了其他两个特点。

二、 threadlocal的作用

大家都知道它的使用场景大都是多线程编程，至于具体的作用，这个怎么说那？我觉得这个只能用一个泛的说法来定义，因为一个东西的功能属性定义了以后会限制大家的思路，就好比说菜刀是用来切菜的，好多人就不会用它切西瓜了。
这里，说下我对它的作用的认识，仅供参考，希望能有所帮助。这样来描述吧，当一个多线程的程序需要对多数线程的部分任务（就是run方法里的部分代码）进行封装时，在封装体里就可以用threadlocal来包装与线程相关的成员变量，从而保证线程访问的独占性，而且所有线程可以共享一个封装体对象；可以参考下android里的looper。不会用代码描述问题的程序员不是好程序员；

看代码：统计线程某段代码耗时的工具（为说明问题自造）

statisticcosttime.java

// class that statistic the cost time

public class statisticcosttime{

// record the starttime

// private threadlocal starttime = new threadlocal();

private long starttime;

// private threadlocal costtime = new threadlocal();

private long costtime;

private statisticcosttime(){

}

//singleton

public static final statisticcosttime shareinstance(){

return instancefactory.instance;

}

private static class instancefactory{

private static final statisticcosttime instance = new statisticcosttime();

}

// start

public void start(){

// starttime.set(system. nanotime ());

starttime = system.nanotime();

}

// end

public void end(){

// costtime.set(system. nanotime () - starttime.get());

costtime = system.nanotime() - starttime;

}

public long getstarttime(){

return starttime;

// return starttime.get();

}

public long getcosttime(){

// return costtime.get();

return costtime;

}

好了，工具设计完工了,现在我们用它来统计一下线程耗时试试呗：

main.java

public class main{

public static void main(string[] args) throws exception{

// define the thread a

thread a = new thread(){

public void run(){

try{

// start record time

statisticcosttime.shareinstance().start();

sleep(200);

// print the start time of a

system.out.println("a-starttime:"+statisticcosttime.shareinstance().getstarttime());

// end the record

statisticcosttime.shareinstance().end();

// print the costtime of a

system.out.println("a:"+statisticcosttime.shareinstance().getcosttime());

}

catch(exception e){

}

;

// start a

a.start();

// define thread b

thread b = new thread(){

public void run(){

try{

// record the start time of b1

statisticcosttime.shareinstance().start();

sleep(100);

// print the start time to console

system.out.println("b1-starttime:"+statisticcosttime.shareinstance().getstarttime());

// end record start time of b1

statisticcosttime.shareinstance().end();

// print the cost time of b1

system.out.println("b1:"+statisticcosttime.shareinstance().getcosttime());

// start record time of b2

statisticcosttime.shareinstance().start();

sleep(100);

// print start time of b2

system.out.println("b2-starttime:"+statisticcosttime.shareinstance().getstarttime());

// end record time of b2

statisticcosttime.shareinstance().end();

// print cost time of b2

system.out.println("b2:"+statisticcosttime.shareinstance().getcosttime());

}

catch(exception e){

}

;

b.start();

}

运行代码后输出结果是这样的
注意：输出结果精确度为纳秒级

看结果是不是和我们预想的不一样，发现a的结果应该约等于b1+b2才对呀，怎么变成和b2一样了那？答案就是我们在定义starttime和costtime变量时，本意是不应共享的，应是线程独占的才对。而这里变量随单例共享了，所以当计算a的值时，其实starttime已经被b2修改了，所以就输出了和b2一样的结果。

现在我们把statisticcosttime中注释掉的部分打开，换成threadlocal的声明方式试下。
看结果：

呀！这下达到预期效果了，这时候有同学会说这不是可以线程并发访问了吗，是不是只要我用了threadlocal就可以保证线程安全了？答案是no！首先先弄明白为什么会有线程安全问题，无非两种情况：
1、不该共享的资源，你在线程间共享了；
2、线程间共享的资源，你没有保证有序访问；
前者可以用“空间换时间”的方式解决，用threadlocal（也可以直接声明线程局部变量），后者用“时间换空间”的方式解决，显然这个就不是threadlocal力所能及的了。

三、 threadlocal 原理

实现原理其实很简单，每次对threadlocal 对象的读写操作其实是对线程的values对象的读写操作；这里澄清一下，没有什么变量副本的创建，因为就没有用变量分配的内存空间来存t对象的，而是用它所在线程的values来存t对象的；我们在线程中每次调用threadlocal的set方法时，实际上是将object写入线程对应values对象的过程；调用threadlocal的get方法时，实际上是从线程对应values对象取object的过程。

看源码：

threadlocal 的成员变量set