01.public class Thread implements Runnable {  
02.    // 这里省略了许多其他的代码   
03.    ThreadLocal.ThreadLocalMap threadLocals = null;  
04.} 

01.public class ThreadLocal<T> {  
02.  
03.    // 这里省略了许多其他代码   
04.  
05.    // 将value的值保存于当前线程的本地变量中   
06.    public void set(T value) {  
07.        // 获取当前线程   
08.        Thread t = Thread.currentThread();  
09.        // 调用getMap方法获得当前线程中的本地变量ThreadLocalMap   
10.        ThreadLocalMap map = getMap(t);  
11.        // 如果ThreadLocalMap已存在，直接使用   
12.        if (map != null)  
13.            // 以当前的ThreadLocal的实例作为key，存储于当前线程的   
14.            // ThreadLocalMap中，如果当前线程中被定义了多个不同的ThreadLocal   
15.            // 的实例，则它们会作为不同key进行存储而不会互相干扰   
16.            map.set(this, value);  
17.        else  
18.            // ThreadLocalMap不存在，则为当前线程创建一个新的   
19.            createMap(t, value);  
20.    }  
21.  
22.    // 获取当前线程中以当前ThreadLocal实例为key的变量值   
23.    public T get() {  
24.        // 获取当前线程   
25.        Thread t = Thread.currentThread();  
26.        // 获取当前线程中的ThreadLocalMap   
27.        ThreadLocalMap map = getMap(t);  
28.        if (map != null) {  
29.            // 获取当前线程中以当前ThreadLocal实例为key的变量值   
30.            ThreadLocalMap.Entry e = map.getEntry(this);  
31.            if (e != null)  
32.                return (T) e.value;  
33.        }  
34.        // 当map不存在时，设置初始值   
35.        return setInitialValue();  
36.    }  
37.  
38.    // 从当前线程中获取与之对应的ThreadLocalMap   
39.    ThreadLocalMap getMap(Thread t) {  
40.        return t.threadLocals;  
41.    }  
42.  
43.    // 创建当前线程中的ThreadLocalMap   
44.    void createMap(Thread t, T firstValue) {  
45.        // 调用构造函数生成当前线程中的ThreadLocalMap   
46.        t.threadLocals = new ThreadLocalMap(this, firstValue);  
47.    }  
48.  
49.    // ThreadLoaclMap的定义   
50.    static class ThreadLocalMap {  
51.        // 这里省略了许多代码   
52.    }  
53.}  

01.public class Counter {  
02.     //新建一个静态的ThreadLocal变量，并通过get方法将其变为一个可访问的对象    
03.     private static ThreadLocal<Integer> counterContext = new ThreadLocal<Integer>(){  
04.         protected synchronized Integer initialValue(){  
05.             return 10;  
06.         }  
07.     };  
08.     // 通过静态的get方法访问ThreadLocal中存储的值   
09.     public static Integer get(){  
10.         return counterContext.get();  
11.     }  
12.     // 通过静态的set方法将变量值设置到ThreadLocal中   
13.     public static void set(Integer value) {    
14.         counterContext.set(value);    
15.     }   
16.     // 封装业务逻辑，操作存储于ThreadLocal中的变量     
17.     public static Integer getNextCounter() {    
18.         counterContext.set(counterContext.get() + 1);    
19.         return counterContext.get();    
20.     }    
21. }  

01.public class ThreadLocalTest extends Thread {  
02.     public void run(){  
03.         for(int i = 0; i < 3; i++){    
04.             System.out.println("Thread[" + Thread.currentThread().getName() + "],counter=" + Counter.getNextCounter());    
05.         }    
06.     }  
07. }  

01.public class Test {  
02.     public static void main(String[] args) {  
03.         ThreadLocalTest testThread1 = new ThreadLocalTest();    
04.         ThreadLocalTest testThread2 = new ThreadLocalTest();    
05.         ThreadLocalTest testThread3 = new ThreadLocalTest();    
06.         testThread1.start();    
07.         testThread2.start();    
08.         testThread3.start();  
09.     }  
10. }  

上面的输出结果也证实了,counter的值在多线程环境中的访问是线程安全的.从对例子的分析中我们可以再次体会到,ThreadLocal模式最合适的使用场景:在同一个线程（Thread）的不同开发层次中共享数据.

　　从上面的例子中,我们可以简单总结出实现ThreadLocal模式的两个主要步骤:
　　1. 建立一个类,并在其中封装一个静态的ThreadLocal变量,使其成为一个共享数据环境.
　　2. 在类中实现访问静态ThreadLocal变量的静态方法（设值和取值）.

　　建立在ThreadLocal模式的实现步骤之上,ThreadLocal的使用则更加简单.在线程执行的任何地方，我们都可以通过访问共享数据类中所提供的ThreadLocal变量的设值和取值方法安全地获得当前线程中安全的变量值.
　　这两个步骤,我们之后会在Struts2的实现中多次提及,读者只要能充分理解ThreadLocal处理多线程访问的基本原理，就能对Struts2的数据访问和数据共享的设计有一个整体的认识.

　　讲到这里,我们回过头来看看ThreadLocal模式的引入,到底对我们的编程模型有什么重要的意义呢?

　　结论 ：使用ThreadLocal模式,可以使得数据在不同的编程层次得到有效地共享,

　　这一点,是由ThreadLocal模式的实现机理决定的.因为实现ThreadLocal模式的一个重要步骤,就是构建一个静态的共享存储空间.从而使得任何对象在任何时刻都可以安全地对数据进行访问.

　　结论 使用ThreadLocal模式,可以对执行逻辑与执行数据进行有效解耦

　　这一点是ThreadLocal模式给我们带来的最为核心的一个影响,因为在一般情况下,Java对象之间的协作关系，主要通过参数和返回值来进行消息传递,这也是对象协作之间的一个重要依赖,而ThreadLocal模式彻底打破了这种依赖关系,通过线程安全的共享对象来进行数据共享,可以有效避免在编程层次之间形成数据依赖,这也成为了XWork事件处理体系设计的核心.