线程知识-ThreadLocal使用详解

最近在看Spring的时候回顾了一下ThreadLocal，下面是ThreadLocal的使用说明。

概述

首先，谈到ThreadLocal的使用，我们先来了解一下ThreadLocal是什么？ThreadLocal是在JDK1,2的版本中开始提供的，他不是一个线程，而是一个线程的本地化对象。当某个变量在使用ThreadLocal进行维护时，ThreadLocal为使用该变量的每个线程分配了一个独立的变量副本，每个线程可以自行操作自己对应的变量副本，而不会影响其他线程的变量副本。

从线程的角度看，每个线程都保持一个对其线程局部变量副本的隐式引用，只要线程是活动的并且 ThreadLocal 实例是可访问的；在线程消失之后，其线程局部实例的所有副本都会被垃圾回收（除非存在对这些副本的其他引用）。
 
通过ThreadLocal存取的数据，总是与当前线程相关，也就是说，JVM 为每个运行的线程，绑定了私有的本地实例存取空间，从而为多线程环境常出现的并发访问问题提供了一种隔离机制。
 
ThreadLocal是如何做到为每一个线程维护变量的副本的呢？其实实现的思路很简单，在ThreadLocal类中有一个Map，用于存储每一个线程的变量的副本。

ThreadLocal的API

ThreadLocal的API提供了如下的4个方法，分别是：

 
T get()
          返回此线程局部变量的当前线程副本中的值，如果这是线程第一次调用该方法，则创建并初始化此副本。
 
protected  T initialValue()
          返回此线程局部变量的当前线程的初始值。最多在每次访问线程来获得每个线程局部变量时调用此方法一次，即线程第一次使用 get() 方法访问变量的时候。如果线程先于 get 方法调用 set(T) 方法，则不会在线程中再调用 initialValue 方法。

          

          若该实现只返回 null；如果程序员希望将线程局部变量初始化为 null 以外的某个值，则必须为 ThreadLocal 创建子类，并重写此方法。通常，将使用匿名内部类。initialValue 的典型实现将调用一个适当的构造方法，并返回新构造的对象。

 
void remove()
          移除此线程局部变量的值。这可能有助于减少线程局部变量的存储需求。如果再次访问此线程局部变量，那么在默认情况下它将拥有其 initialValue。
 
void set(T value)
          将此线程局部变量的当前线程副本中的值设置为指定值。许多应用程序不需要这项功能，它们只依赖于 initialValue() 方法来设置线程局部变量的值。
 
在程序中一般都重写initialValue方法，以给定一个特定的初始值。

在上面的概述中也说到，其实ThreadLocal就是Map的一个应用，下面来看一个ThreadLocal实现的简单模拟版本。

ThreadLocal简单模拟实现

[java]  view plain copy

1. package org.lmu.threadlocal;  
2.   
3. import java.util.Collections;  
4. import java.util.HashMap;  
5. import java.util.Map;  
6.   
7. public class ThreadLocal<T> {  
8.     private Map<Thread,T> map = Collections.synchronizedMap(new HashMap<Thread, T>());  
9.         
10.     /** 
11.      * 取得线程局部变量的值 
12.      * @return 线程局部变量的值 
13.      */  
14.     public T get(){  
15.         Thread currenThread = Thread.currentThread();  
16.         T temp = map.get(currenThread);//取得线程局部变量的值  
17.         if(temp==null&&map.containsKey(currenThread)){  
18.             temp = initialValue();  
19.             map.put(currenThread, temp);  
20.         }   
21.         return temp;  
22.     }  
23.       
24.     /** 
25.      * 设置当前线程局部变量的值 
26.      * @param value 局部变量需设的值 
27.      */  
28.     public void set(T value){   
29.         map.put(Thread.currentThread(), value);  
30.     }  
31.       
32.     /** 
33.      * 将线程局部变量的值删除 
34.      */  
35.     public void remove(){  
36.         map.remove(Thread.currentThread());  
37.     }  
38.       
39.     /** 
40.      * 线程局部变量初始值 
41.      * @return 初始值为null 
42.      */  
43.     public T initialValue(){  
44.         return null;  
45.     }  
46. }  

ThreadLocal实例 

[java]  view plain copy

1. package org.lmu.threadlocal;  
2.   
3. public class ThreadLocalTest {  
4.     //通过覆写ThreadLocal中的initialValue方法为线程局部变量初始化之为0  
5.     ThreadLocal<Integer> tlNum = new ThreadLocal<Integer>(){  
6.    
7.         protected Integer initialValue() {   
8.             return 0;  
9.         }  
10.           
11.     };  
12.       
13.     /** 
14.      *  
15.      * @return 下一个值 
16.      */  
17.     public int getNextNum(){  
18.         Integer num = tlNum.get();//取得下一个值  
19.         tlNum.set(num+1);//设置下一个值  
20.         return num;//返回取得的值  
21.     }  
22.       
23.     private static class TestThread implements Runnable{  
24.         private ThreadLocalTest tlt;  
25.           
26.         public TestThread(ThreadLocalTest tlt) {  
27.             this.tlt = tlt;  
28.         }  
29.         public void run() {  
30.             int n = 3;  
31.             for (int i = 0; i < n; i++) {  
32.                 System.out.println("线程【"+Thread.currentThread().getName()+"】-线程变量值【"+tlt.getNextNum()+"】");  
33.             }  
34.         }  
35.     }   
36.       
37.       
38.     public static void main(String[] args) {  
39.           
40.         //TestThread tt1 = new TestThread(new ThreadLocalTest());  
41.         //TestThread tt2 = new TestThread(new ThreadLocalTest());  
42.         //TestThread tt3 = new TestThread(new ThreadLocalTest());  
43.         //之前这样写是不正确的  
44.   
45.         ThreadLocalTest tlt = new ThreadLocalTest();  
46.         TestThread tt1 = new TestThread(tlt);  
47.         TestThread tt2 = new TestThread(tlt);  
48.         TestThread tt3 = new TestThread(tlt);  
49.         Thread t1 = new Thread(tt1);  
50.         Thread t2 = new Thread(tt2);  
51.         Thread t3 = new Thread(tt3);  
52.         t1.start();  
53.         t2.start();  
54.         t3.start();  
55.     }  
56. }  

上面的例子中使用ThreadLocal来维护数值变量，初始值设置为0，,并在线程实现中打印3个序列值，这里提供3个线程进行测试，下面是测试的结果。

线程【Thread-2】-线程变量值【0】
线程【Thread-1】-线程变量值【0】
线程【Thread-0】-线程变量值【0】
线程【Thread-1】-线程变量值【1】
线程【Thread-2】-线程变量值【1】
线程【Thread-1】-线程变量值【2】
线程【Thread-0】-线程变量值【1】
线程【Thread-0】-线程变量值【2】
线程【Thread-2】-线程变量值【2】

从结果中可以看到，每个线程都可以独立的操作对应的副本，不会出现相互干扰的情况。

ThreadLocal与Thread同步机制的比较

在同步机制中，通过对象所机制保证同一个时间只能有一个线程访问变量。而ThreadLocal则从列一个角度来解决多线程的并发访问。

概括起来说，对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。