java多线程模式ThreadLocal原理简述及其使用详解

原创整理不易，转载请注明出处：java多线程模式ThreadLocal原理简述及其使用详解

代码下载地址：http://www.zuidaima.com/share/1781557457128448.htm

ThreadLocal是为了使每个线程保存一份属于自己的数据。
先看一个使用ThreadLocal的实例。

[java] view plaincopy

1.  package com.zuidaima.aop.framework;  
2.   
3.  import com.zuidaima.core.NamedThreadLocal;  
4.   
5.  public abstract class AopContext {  
6.   
7.  private static final ThreadLocal <Object> currentProxy= new NamedThreadLocal <Object> ( " Current AOP proxy " );  
8.   
9.  public static Object currentProxy() throws IllegalStateException {  
10.  Object proxy= currentProxy.get();  
11.  if (proxy== null ) {  
12.  throw new IllegalStateException(  
13.  " Cannot find current proxy: Set 'exposeProxy' property on Advised to 'true' to make it available. " );  
14.  }  
15.  return proxy;  
16.  }  
17.   
18.  static Object setCurrentProxy(Object proxy) {  
19.  Object old= currentProxy.get();  
20.  if (proxy != null ) {  
21.  currentProxy.set(proxy);  
22.  }  
23.  else {  
24.  currentProxy.remove();  
25.  }  
26.  return old;  
27.  }  
28.   
29. }  

上例展示的是spring框架中获取当前线程的代理对象的方法，AopContext.currentProxy()，在本线程的程序调用栈中只要调用AopContext的静态方法就可以获取本线程相关的代理对象。如果不用ThreadLocal，那么这个代理对象在创建后，就要一层层传递下去，才能在后面获取到并使用。
通过这个例子，我们可以知道[b]ThreadLocal主要是提供了一种保持对象的方法以及避免了对象在程序调用中传递的简便访问方法。ThreadLocal与共享数据和同步没有明显关系。[/b]

下面看看相关的源码以了解具体的结构。

[java] view plaincopy

1. public class Thread implements Runnable {  
2.  // ThreadLocalMap是一个以ThreadLocal为key，Object为值的map，由ThreadLocal维护   
3.  ThreadLocal.ThreadLocalMap threadLocals= null ;  
4. }  

从Thread的源码中可以得知，是每一个Thread持有一个自己的map，并不是一个ThreadLocal持有一个map。

[java] view plaincopy

1. public class ThreadLocal <T> {  
2.   
3. public T get() {  
4. // 获取当前线程   
5. Thread t= Thread.currentThread();  
6. // 获取当前线程的threadLocals变量   
7. ThreadLocalMap map= getMap(t);  
8. // 从当前线程的threadLocals变量中取得本threadLocal为key的值   
9. if (map != null ) {  
10. ThreadLocalMap.Entry e= map.getEntry( this );  
11. if (e != null )  
12. return (T)e.value;  
13. }  
14. return setInitialValue();  
15. }  
16.   
17. private T setInitialValue() {  
18. T value= initialValue();  
19. Thread t= Thread.currentThread();  
20. ThreadLocalMap map= getMap(t);  
21. if (map != null )  
22. map.set( this , value);  
23. else   
24. createMap(t, value);  
25. return value;  
26. }  
27.   
28.   
29. public void set(T value) {  
30. // 获取当前线程   
31. Thread t= Thread.currentThread();  
32. // 获取当前线程的threadLocals变量   
33. ThreadLocalMap map= getMap(t);  
34. // 以本threadLocal为key的保存值到当前线程的threadLocals变量中去   
35. if (map != null )  
36. map.set( this , value);  
37. else   
38. createMap(t, value);  
39. }  
40.   
41. ThreadLocalMap getMap(Thread t) {  
42. return t.threadLocals;  
43. }  
44.   
45. void createMap(Thread t, T firstValue) {  
46. t.threadLocals= new ThreadLocalMap( this , firstValue);  
47. }  

使用ThreadLocal过程： 对于每一个需要线程保存自身实例的变量，需要定义一个静态的ThreadLocal实例。然后将一个共用的ThreadLocal静态实例作为key，将不同对象的引用保存到不同线程的ThreadLocalMap中，然后在线程执行的各处通过这个静态ThreadLocal实例的get()方法取得自己线程保存的那个对象。
此外，每个线程保存的自身数据并不是通过备份或复制的，而是new创建出来的。

通过ThreadLocal各个线程只能获取自身对应的数据，不能访问其他线程的数据，但是如果两个线程在set时引用了同一个数据，仍然存在同步问题