ThreadLocal设计模式 .

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. }