java.lang.ThreadLocal<T>的具体实现

截取自：http://blog.csdn.net/lufeng20/article/details/24314381

文中简要简要介绍了 ThreadLocal核心部分。

那么到底ThreadLocal类是如何实现这种“为每个线程提供不同的变量拷贝”的呢？先来看一下ThreadLocal的set()方法的源码是如何实现的：

[java]  view plain  copy

 print ?

1. /** 
2.     * Sets the current thread's copy of this thread-local variable 
3.     * to the specified value.  Most subclasses will have no need to 
4.     * override this method, relying solely on the {@link #initialValue} 
5.     * method to set the values of thread-locals. 
6.     * 
7.     * @param value the value to be stored in the current thread's copy of 
8.     *        this thread-local. 
9.     */  
10.    public void set(T value) {  
11.        Thread t = Thread.currentThread();  
12.        ThreadLocalMap map = getMap(t);  
13.        if (map != null)  
14.            map.set(this, value);  
15.        else  
16.            createMap(t, value);  
17.    }  

在这个方法内部我们看到，首先通过getMap(Thread t)方法获取一个和当前线程相关的ThreadLocalMap，然后将变量的值设置到这个ThreadLocalMap对象中，当然如果获取到的ThreadLocalMap对象为空，就通过createMap方法创建。


线程隔离的秘密，就在于ThreadLocalMap这个类。ThreadLocalMap是ThreadLocal类的一个静态内部类，它实现了键值对的设置和获取（对比Map对象来理解），每个线程中都有一个独立的ThreadLocalMap副本，它所存储的值，只能被当前线程读取和修改。ThreadLocal类通过操作每一个线程特有的ThreadLocalMap副本，从而实现了变量访问在不同线程中的隔离。因为每个线程的变量都是自己特有的，完全不会有并发错误。还有一点就是，ThreadLocalMap存储的键值对中的键是this对象指向的ThreadLocal对象，而值就是你所设置的对象了。


为了加深理解，我们接着看上面代码中出现的getMap和createMap方法的实现：

[java]  view plain  copy

 print ?

1. /** 
2.  * Get the map associated with a ThreadLocal. Overridden in 
3.  * InheritableThreadLocal. 
4.  * 
5.  * @param  t the current thread 
6.  * @return the map 
7.  */  
8. ThreadLocalMap getMap(Thread t) {  
9.     return t.threadLocals;  
10. }  
11.   
12. /** 
13.  * Create the map associated with a ThreadLocal. Overridden in 
14.  * InheritableThreadLocal. 
15.  * 
16.  * @param t the current thread 
17.  * @param firstValue value for the initial entry of the map 
18.  * @param map the map to store. 
19.  */  
20. void createMap(Thread t, T firstValue) {  
21.     t.threadLocals = new ThreadLocalMap(this, firstValue);  
22. }  

接下来再看一下ThreadLocal类中的get()方法:

[java]  view plain  copy

 print ?

1. /** 
2.  * Returns the value in the current thread's copy of this 
3.  * thread-local variable.  If the variable has no value for the 
4.  * current thread, it is first initialized to the value returned 
5.  * by an invocation of the {@link #initialValue} method. 
6.  * 
7.  * @return the current thread's value of this thread-local 
8.  */  
9. public T get() {  
10.     Thread t = Thread.currentThread();  
11.     ThreadLocalMap map = getMap(t);  
12.     if (map != null) {  
13.         ThreadLocalMap.Entry e = map.getEntry(this);  
14.         if (e != null)  
15.             return (T)e.value;  
16.     }  
17.     return setInitialValue();  
18. }  

再来看setInitialValue()方法：

[java]  view plain  copy

 print ?

1. /** 
2.     * Variant of set() to establish initialValue. Used instead 
3.     * of set() in case user has overridden the set() method. 
4.     * 
5.     * @return the initial value 
6.     */  
7.    private T setInitialValue() {  
8.        T value = initialValue();  
9.        Thread t = Thread.currentThread();  
10.        ThreadLocalMap map = getMap(t);  
11.        if (map != null)  
12.            map.set(this, value);  
13.        else  
14.            createMap(t, value);  
15.        return value;  
16.    }  

　　获取和当前线程绑定的值时，ThreadLocalMap对象是以this指向的ThreadLocal对象为键进行查找的，这当然和前面set()方法的代码是相呼应的。


　　进一步地，我们可以创建不同的ThreadLocal实例来实现多个变量在不同线程间的访问隔离，为什么可以这么做？因为不同的ThreadLocal对象作为不同键，当然也可以在线程的ThreadLocalMap对象中设置不同的值了。通过ThreadLocal对象，在多线程中共享一个值和多个值的区别，就像你在一个HashMap对象中存储一个键值对和多个键值对一样，仅此而已。

小结

　　ThreadLocal是解决线程安全问题一个很好的思路，它通过为每个线程提供一个独立的变量副本解决了变量并发访问的冲突问题。在很多情况下，ThreadLocal比直接使用synchronized同步机制解决线程安全问题更简单，更方便，且结果程序拥有更高的并发性。

ConnectionManager.java

[java]  view plain  copy

 print ?

1. package com.test;  
2.   
3. import java.sql.Connection;  
4. import java.sql.DriverManager;  
5. import java.sql.SQLException;  
6.   
7. public class ConnectionManager {  
8.   
9.     private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>() {  
10.         @Override  
11.         protected Connection initialValue() {  
12.             Connection conn = null;  
13.             try {  
14.                 conn = DriverManager.getConnection(  
15.                         "jdbc:mysql://localhost:3306/test", "username",  
16.                         "password");  
17.             } catch (SQLException e) {  
18.                 e.printStackTrace();  
19.             }  
20.             return conn;  
21.         }  
22.     };  
23.   
24.     public static Connection getConnection() {  
25.         return connectionHolder.get();  
26.     }  
27.   
28.     public static void setConnection(Connection conn) {  
29.         connectionHolder.set(conn);  
30.     }  
31. }  

后记

　　看到网友评论的很激烈，甚至关于ThreadLocalMap不是ThreadLocal里面的，而是Thread里面的这种评论都出现了，于是有了这个后记，下面先把jdk源码贴上，源码最有说服力了。

[java]  view plain  copy

 print ?

1. /** 
2.      * ThreadLocalMap is a customized hash map suitable only for 
3.      * maintaining thread local values. No operations are exported 
4.      * outside of the ThreadLocal class. The class is package private to 
5.      * allow declaration of fields in class Thread.  To help deal with 
6.      * very large and long-lived usages, the hash table entries use 
7.      * WeakReferences for keys. However, since reference queues are not 
8.      * used, stale entries are guaranteed to be removed only when 
9.      * the table starts running out of space. 
10.      */  
11.     static class ThreadLocalMap {...}  

　　源码就是以上，这源码自然是在ThreadLocal里面的，有截图为证。

　　本文是自己在学习ThreadLocal的时候，一时兴起，深入看了源码，思考了此类的作用、使用范围，进而联想到对传统的synchronize共享变量线程安全的问题进行比较，而总结的博文，总结一句话就是一个是锁机制进行时间换空间，一个是存储拷贝进行空间换时间。