我们再介绍一个在多线程环境中经常使用的类ThreadLocal，它是java为解决多线程程序的并发问题提供了一种新的方向，使用这个ThreadLocal类可以帮助开发者很简单地编写出简洁的程序，并且是线程安全的。ThreadLocal很容易让人误解，认为是一个“本地线程”，其实ThreadLocal并不是一个Thread，而是Thread的一个局部变量。
当使用ThreadLocal变量时，ThreadLocal为每个使用这个变量的线程提供不同的变量副本，所以每一个线程改变的只是自己的副本，而不会影响其它线程所对应的副本。从线程的角度看，目标变量就象是线程的本地变量。我们先来了解一下ThreadLocal的接口方法
ThreadLocal类提供的接口方法比较简单，很容易使用：
public void set(Object value) 该方法设置当前线程局部变量的值。
public Object get() 该方法返回当前线程所对应的线程局部变量的值。
public void remove() 该方法删除当前线程局部变量的值，目的是为了减少内存的占用，该方法是JDK 5.0新增的方法。这这里需要说明的是，当线程结束后，该线程的所有局部变量将自动被垃圾回收器(GC)回收，所以显式调用该方法清除线程的某些局部变量并不是必须的操作，但它可以加快内存回收的速度。
protected Object initialValue() 返回该线程局部变量的初始值，该方法是一个protected的方法，显然是为了让子类覆盖而设计的，ThreadLocal中的缺省实现直接返回一个null。
下面举一个列子来说明一下他的用法。
public class TestThreadLocal {
static class myRunnable implements
Runnable {
int index;
public myRunnable(int i){
index
=i;
}
public void run() {
myThreadLocal.set("Thread:"+
index);
System.out.println(myThreadLocal.get());
}
}
public static ThreadLocal<String> myThreadLocal = new
ThreadLocal<String>();
public static void main(String[]
args){
Thread thread1 = new Thread(new myRunnable(1));
Thread thread2
= new Thread(new
myRunnable(2));
thread1.start();
thread2.start();
System.out.println(myThreadLocal.get());
}
}
执行的结果如下：
Thread:1
Thread:2
null
thread 1 返回Thread:1的结果，thread2返回Thread:2，最后一个null是main线程的执行结果，因为 main线程没有设置自己的局部变量。
ThreadLocal的实现原理
在介绍ThreadLocal变量之前，我们先来看一个Thread的内部变量：
ThreadLocal.ThreadLocalMap threadLocals = null;
这个变量就是线程用来存储自己的ThreadLocal变量的空间，他的类型 ThreadLocal.ThreadLocalMap，作用相当于一个hashmap,对这种数据类型的操作是不需要加锁的，因为只有一个线程（也就是线程自己）才可能操作到自己的变量。
我们先看ThreadLocal源代码是来解析两个比较重要的函数：set和get
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);//拿到本地线程map
if (map != null)
map.set(this, value);//map存在时，添加value
else
createMap(t, value);//map不存在时，创建map并且添加value
}
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t); //拿到本地线程map
if (map != null) {//map存在时，或者key
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null)
return (T)e.value;
}
return setInitialValue();
}
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
从代码上看，ThreadLocal函数都是先获得当前线程的引用，然后得到线程局部变量，最后以ThreadLocal作为key，设置或者获取value，线程本地变量是类型为ThreadLocalMap的变量，ThreadLocalMap相当于一种哈希表，有兴趣的可以看一下。整个过程没有任何同步操作，因此性能很高。
ThreadLocal与其它同步机制的比较
ThreadLocal和线程同步机制都是为了解决多线程访问变量冲突的问题，同步机制是通过对象的锁机制保证同一时间只有一个线程访问变量，此时该变量是多个线程共享的，使用同步机制要求用户分析什么时候对变量进行读写，什么时候需要锁定某个对象，什么时候释放对象锁等复杂的问题，程序设计和编写难度相对比较大。而ThreadLocal则从另一个角度来解决多线程的并发访问，它会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突，因为每一个线程都拥有自己的变量副本，它只操作自己的变量副本，从而也就没有必要对该变量进行同步了。
当然ThreadLocal并不能替代同步机制，两者面向的问题不同。同步机制是为了同步多个线程对相同资源的并发访问，是为了多个线程之间进行通信的有效方式；而ThreadLocal是隔离多个线程的数据共享，从根本上就不在多个线程之间共享资源，这样当然不需要对多个线程进行同步了。所以，如果你需要进行多个线程之间进行通信，则使用同步机制；如果需要隔离多个线程之间的共享冲突，可以使用ThreadLocal，这将极大地简化你的程序，使程序更加易读、简洁。
InheritableThreadLocal
通常线程还需要维护另外一个变量 inheritableThreadLocals
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null
当创建一个新的线程时，线程会从父线程哪里复制一份数据。也就是是说，子线程会享有父线程的数据，下面的代码摘自Thread.init函数，子线程创建时，将会调用。
if (parent.inheritableThreadLocals != null)
this.inheritableThreadLocals =
ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
请看它的getMap函数，显然操作的是inheritableThreadLocals变量
ThreadLocalMap getMap(Thread t) {
return t.inheritableThreadLocals;
}
这时所有的操作都是针对Thread的inheritableThreadLocals，这种操作也是线程安全的。
我们来举一个例子来说明InheritableThreadLocal的说法
public class TestInheritableThreadLocal {
static class myRunnable
implements Runnable {
int index;
public myRunnable(int
i){
index =i;
}
public void run()
{
//
System.out.println("thread " + index + "-" +
myThreadLocal.get());
myThreadLocal.set("Thread:"+
index);
System.out.println("thread " + index + "-" +
myThreadLocal.get());
}
}
public static InheritableThreadLocal<String> myThreadLocal = new
InheritableThreadLocal<String>();
public static void
main(String[] args){
myThreadLocal.set("parent main
thread");
Thread thread1 = new Thread(new myRunnable(1));
Thread
thread2 = new Thread(new
myRunnable(2));
thread1.start();
thread2.start();
try
{
thread1.join();
thread2.join();
} catch (InterruptedException
e) {
// TODO Auto-generated catch
block
e.printStackTrace();
}
System.out.println("main thead
-" + myThreadLocal.get());
}
}
结果如下：
thread 1-parent main thread
thread 2-parent main thread
thread
2-Thread:2
thread 1-Thread:1
main thead -parent main thread
线程1和线程2会共享main线程的数据，子线程也可以修改自己的副本，修改后，线程1得到的结果Thread:1，线程2得到结果Thread:2
而父线程（main）的变量时不会噶边的，因为子线程的修改只作用于自己的变量空间，不会作用到父线程。
概括起来说，对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而不受影响。
原文地址：http://www.cnblogs.com/easycloud/p/3729894.html
