ThreadLocal

设计理念

为每个线程创造一个资源的复本。将每一个线程存取数据的行为加以隔离，实现的方法就是给予每个线程一个特定空间来保管该线程所独享的资源。

作用

为每一个使用该变量的线程都提供一个变量值的副本，是每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。从线程的角度看，就好像每一个线程都完全拥有该变量。

使用

ThreadLocal实例通常是类中的private static字段，它们希望将状态与某一个线程相关联。每个线程都保持对其线程局部变量副本的隐式引用，只要线程是活动的并且ThreadLocal实例是可访问的，在线程消失之后，其线程局部实例的所有副本都会被垃圾回收（除非存在对这些副本的其他引用）。
首先创建ThreadLocal对象：

1.  ThreadLocal<Integer> mValue=new 
ThreadLocal<Integer>();

然后在线程中调用set和get方法来设置和获取值，例如：

1.  mValue.set(1); 
2.  int value=mValue.get();

2.4 实现原理
简单地说，就是在ThreadLocal类中有一个Map，用于存储每一个线程的变量的副本。Map的Key是Thread，value就是副本的值。
深入源码去看，ThreadLocal把线程和线程局部变量存在ThreadLocalMap中，而ThreadLocalMap是ThreadLocal的静态类部类，我们来看看ThreadLocalMap的部分源码：

1.  static class Entry extends WeakReference<ThreadLocal<?>> { 
2.   
3.      Object value; 
4.      Entry(ThreadLocal<?> k, Object v) { 
5.          super(k); 
6.          value = v; 
7.      } 
8.  }

这个Map的key是ThreadLocal对象的弱引用，当要抛弃掉ThreadLocal对象时，垃圾收集器会忽略这个key的引用而清理掉ThreadLocal对象 。
那么到底是ThreadLocal还是Thread持有ThreadLocalMap对象的引用呢？
我们在Thread源码中发现：

1.  /* ThreadLocal values pertaining to this thread.  
2.   * This map is maintained by the ThreadLocal class. 
3.   */ 
4.  ThreadLocal.ThreadLocalMap threadLocals = null;

ThreadLocalMap变量属于Thread的内部属性,不同的Thread拥有完全不同的ThreadLocalMap变量.　 　　Thread中的ThreadLocalMap变量的值是在ThreadLocal对象进行set或者get操作时创建的.　 　　 在创建ThreadLocalMap之前,会首先检查当前Thread中的ThreadLocalMap变量是否已经存在,如果不存在则创建一个；如果已经存在,则使用当前Thread已创建的ThreadLocalMap.

ThreadLocal的接口方法

1.  /** 
2.   * 返回此线程局部变量的初始值 
3.   * 
4.   * 线程第一次使用 get() 方法访问变量时将调用此方法，但如果线程之前调用 
5.   * 了 set(T) 方法，则不会对该线程再调用 initialValue 方法。通常，此 
6.   * 方法对每个线程最多调用一次，但如果在调用 get() 后又调用了  
7.   * remove()，则可能再次调用此方法。 
8.   *  
9.   * 该实现返回 null；如果程序员希望线程局部变量具有 null 以外的值，则 
10.  * 必须为 ThreadLocal 创建子类，并重写此方法。通常将使用匿名内部类完 
11.  * 成此操作。 
12. */ 
13. protected T initialValue(); 
14.  
15. /** 
16. * 返回此线程局部变量的当前线程的值 
17. *  
18. * 如果变量没有用于当前线程的值，则先 
19. * 将其初始化为调用initialValue() 方法返回的值。 
20. */ 
21. public T get(); 
22.  
23. /** 
24. * 将此线程局部变量的当前线程副本中的值设置为指定值 
25. *  
26. * 大部分子类不需要重写此方法，它们只依靠 initialValue() 方法 
27. * 来设置线程局部变量的值 
28. */ 
29. public void set(T value); 
30.  
31. /** 
32. * 移除此线程局部变量当前线程的值 
33. *  
34. * 如果此线程局部变量随后被当前线程 读取，且这期间当前线程没有 
35. * 设置其值，则将调用其 initialValue() 方法重新初始化其值。 
36. * 这将导致在当前线程多次调用 initialValue 方法。 
37. */ 
38. public void remove();

如果希望线程局部变量初始化其它值，那么需要自己实现ThreadLocal的子类并重写该方法，通常使用一个内部类对ThreadLocal进行实例化。
比如下面的例子，SerialNum类为每一个类分配一个序号：

1.  public class SerialNum { 
2.      // The next serial number to be assigned 
3.      private static int nextSerialNum = 0; 
4.   
5.      private static ThreadLocal serialNum = new ThreadLocal() { 
6.          protected synchronized Object initialValue() { 
7.              return new Integer(nextSerialNum++); 
8.          } 
9.      } 
10.  
11.     public static int get() { 
12.         return ((Integer) (serialNum.get())).intValue(); 
13.     } 
14. }

ThreadLocal如何做到线程安全

从上面的分析我们可以得出：
• 因为每个Thread在进行对象访问时,访问的都是各自线程自己的ThreadLocalMap，所以保证了Thread与Thread之间的数据访问隔离。
• 不同的ThreadLocal实例操作同一Thread时，ThreadLocalMap在存储时采用当前ThreadLocal的实例作为key来保证数据访问隔离（上面源码Entry处可以看出）。　
举个例子说明：

1.  public class Test{ 
2.      static ThreadLocal<Integer> local=new ThreadLocal<Integer>(){ 
3.          protected synchronized Integer initialValue(){   
4.              return 0;   
5.          } 
6.      };   
7.   
8.      public static void main( String args[]){ 
9.           testRun t = new testRun(); 
10.          new Thread(t).start(); 
11.          new Thread(t).start(); 
12.     } 
13.  
14.     public static  class testRun implements Runnable{ 
15.     @Override 
16.     public void run() { 
17.         // TODO Auto-generated method stub 
18.         for(int i=5 ;i>0;i--){ 
19.             try {   
20.                 Thread.sleep(1000);   
21.             } catch (InterruptedException e) {   
22.                 e.printStackTrace();   
23.             } 
24.             System.out.println(Thread.currentThread().getName()+"::"+local.get()); 
25.  
26.              int localValue=local.get();   
27.              local.set(++localValue);   
28.                 }  
29.         } 
30.     }    
31.    }

输出结果为：

1.  Thread-0::0 
2.  Thread-1::0 
3.  Thread-0::1 
4.  Thread-1::1 
5.  Thread-1::2 
6.  Thread-0::2 
7.  Thread-1::3 
8.  Thread-0::3 
9.  Thread-0::4 
10. Thread-1::4

TheadLocal模式与同步机制的区别

1.实现机制

同步机制采用了“以时间换空间”的方式,提供一份变量,让不同的线程排队访问.
而ThreadLocal采用了“以空间换时间”的方式,为每一个线程都提供一份变量的副本,从而实现同时访问而互不影响。

2.同步共享方面

Java中的synchronized是一个保留字,它依靠JVM的锁机制来实现临界区的函数或者变量的访问中的原子性.在同步机制中,通过对象的锁机制保证同一时间只有一个线程访问变量.此时,被用作“锁机制”的变量是多个线程共享的；
而ThreadLocal会为每一个线程维护一个和该线程绑定的变量的副本，从而隔离了多个线程的数据，每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。　 　 #### 3.使用场合
同步机制是为了同步多个线程对相同资源的并发访问，是为了多个线程之间进行通信的有效方式。
而ThreadLocal是隔离多个线程的数据共享，从根本上就不在多个线程之间共享资源（变量），这样当然不需要对多个线程进行同步了。
所以，如果你需要进行多个线程之间进行通信，则使用同步机制。如果需要隔离多个线程之间的共享冲突，可以使用ThreadLocal。