ThreadLocal防止并发线程安全 线程隔离-ThreadLocalMap

Spring使用ThreadLocal解决线程安全问题我们知道在一般情况下，只有无状态的Bean才可以在多线程环境下共享，在Spring中，绝大部分Bean都可以声明为singleton作用域。就是因为Spring对一些Bean（如RequestContextHolder、TransactionSynchronizationManager、LocaleContextHolder等）中非线程安全状态采用ThreadLocal进行处理，让它们也成为线程安全的状态，因为有状态的Bean就可以在多线程中共享了。

　　一般的Web应用划分为展现层、服务层和持久层三个层次，在不同的层中编写对应的逻辑，下层通过接口向上层开放功能调用。在一般情况下，从接收请求到返回响应所经过的所有程序调用都同属于一个线程，如图9‑2所示：

　　同一线程贯通三层这样你就可以根据需要，将一些非线程安全的变量以ThreadLocal存放，在同一次请求响应的调用线程中，所有关联的对象引用到的都是同一个变量。

　　下面的实例能够体现Spring对有状态Bean的改造思路：

代码清单3 TestDao：非线程安全

[java]  view plain copy print ?

1. package com.test;  
2.   
3. import java.sql.Connection;  
4. import java.sql.SQLException;  
5. import java.sql.Statement;  
6.   
7. public class TestDao {  
8.     private Connection conn;// ①一个非线程安全的变量  
9.   
10.     public void addTopic() throws SQLException {  
11.         Statement stat = conn.createStatement();// ②引用非线程安全变量  
12.         // …  
13.     }  
14. }  

由于①处的conn是成员变量，因为addTopic()方法是非线程安全的，必须在使用时创建一个新TopicDao实例（非singleton）。下面使用ThreadLocal对conn这个非线程安全的“状态”进行改造：

代码清单4 TestDao：线程安全

[java]  view plain copy print ?

1. package com.test;  
2.   
3. import java.sql.Connection;  
4. import java.sql.SQLException;  
5. import java.sql.Statement;  
6.   
7. public class TestDaoNew {  
8.     // ①使用ThreadLocal保存Connection变量  
9.     private static ThreadLocal<Connection> connThreadLocal = new ThreadLocal<Connection>();  
10.   
11.     public static Connection getConnection() {  
12.         // ②如果connThreadLocal没有本线程对应的Connection创建一个新的Connection，  
13.         // 并将其保存到线程本地变量中。  
14.         if (connThreadLocal.get() == null) {  
15.             Connection conn = getConnection();  
16.             connThreadLocal.set(conn);  
17.             return conn;  
18.         } else {  
19.             return connThreadLocal.get();// ③直接返回线程本地变量  
20.         }  
21.     }  
22.   
23.     public void addTopic() throws SQLException {  
24.         // ④从ThreadLocal中获取线程对应的Connection  
25.         Statement stat = getConnection().createStatement();  
26.     }  
27. }  

　　不同的线程在使用TopicDao时，先判断connThreadLocal.get()是否是null，如果是null，则说明当前线程还没有对应的Connection对象，这时创建一个Connection对象并添加到本地线程变量中；如果不为null，则说明当前的线程已经拥有了Connection对象，直接使用就可以了。这样，就保证了不同的线程使用线程相关的Connection，而不会使用其它线程的Connection。因此，这个TopicDao就可以做到singleton共享了。

　　当然，这个例子本身很粗糙，将Connection的ThreadLocal直接放在DAO只能做到本DAO的多个方法共享Connection时不发生线程安全问题，但无法和其它DAO共用同一个Connection，要做到同一事务多DAO共享同一Connection，必须在一个共同的外部类使用ThreadLocal保存Connection。

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

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

那么到底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. }