学习ThreadLocal

1.Whats this?

    ThreadLocal是在jdk1.2发行的一个用于维护变量的工具类，
    详情：JAVA.LANG.THREADLOCAL.使用这个工具类可以简洁编写多线程程序。

---

2.总体介绍

使用ThreadLocal维护变量时，每个使用变量的线程将会提供独立的副本。 
从线程的角度来看，目标变量就像是本地变量。
ThreadLocal提供了以下接口：
1.void set(Object value)设置当前线程的线程局部变量的值。
2.public Object get()该方法返回当前线程所对应的线程局部变量。
3.public void remove()
将当前线程局部变量的值删除，目的是为了减少内存的占用.
该方法是JDK 5.0新增的方法。需要指出的是，当线程结束后， 
对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程
的局部变量并不是必须的操作，但它可以加快内存回收的速度。
在JDK1.5之后，ThreadLocal已经可以支持泛型。

3.原理

思路：在threadLocal类中有一个map，用于存储每一个线程 
的变量副本，map中的元素键为线程对象，值对应副本变量

4.Thread同步机制比较

Threadlocal：解决多线程访问变量冲突的问题。以空间换时间。
同步机制：通过对象锁机制保证同一时间只能有一个线程访问变量。
这时该变量是多个线程共享的，使用同步机制要求程序慎密分析什么 
时候对变量进行读写，什么时候需要锁定某个对象，什么时候释放锁
，难度较大。以时间换空间。

5.应用

spring使用threadlocal解决线程安全问题。
我们知道在一班情况下，只有无状态bean才可以在多线程环境下共享，
在spring中，绝大部分bean都可以声明为singleton作用域。就是因为spring对一些bean（requestContextHolder,TransactionSynchronizationManager,LocaleContextHoder等） 
中非线程安全状态采用threadlocal进行处理，让他们成为线程安全状态，
因为有状态的bean就可以在多线程中共享了。
web应用三层架构。
　一般的Web应用划分为展现层、服务层和持久层三个层次，在不同的层 
　中编写对应的逻辑，下层通过接口向上层开放功能调用。在一般情况下， 
　从接收请求到返回响应所经过的所有程序调用都同属于一个线程。
![这里写图片描述](http://img.zdnet.com.cn/0/438/liOsRM8PmNF4U.gif)
同一线程贯通三层这样你就可以根据需要，将一些非线程安全的变量 
以ThreadLocal存放，在同一次请求响应的调用线程中， 
所有关联的对象引用到的都是同一个变量。

---

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

package com.test;  

import java.sql.Connection;  
import java.sql.SQLException;  
import java.sql.Statement;  

public class TestDao {  
    private Connection conn;// ①一个非线程安全的变量  

    public void addTopic() throws SQLException {  
        Statement stat = conn.createStatement();// ②引用非线程安全变量  
        // …  
    }  
}  

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

package com.test;  

import java.sql.Connection;  
import java.sql.SQLException;  
import java.sql.Statement;  

public class TestDaoNew {  
    // ①使用ThreadLocal保存Connection变量  
    private static ThreadLocal<Connection> connThreadLocal = new ThreadLocal<Connection>();  

    public static Connection getConnection() {  
        // ②如果connThreadLocal没有本线程对应的Connection创建一个新的Connection，  
        // 并将其保存到线程本地变量中。  
        if (connThreadLocal.get() == null) {  
            Connection conn = getConnection();  
            connThreadLocal.set(conn);  
            return conn;  
        } else {  
            return connThreadLocal.get();// ③直接返回线程本地变量  
        }  
    }  

    public void addTopic() throws SQLException {  
        // ④从ThreadLocal中获取线程对应的Connection  
        Statement stat = getConnection().createStatement();  
    }  
}  

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

---

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

package com.test;  

import java.sql.Connection;  
import java.sql.DriverManager;  
import java.sql.SQLException;  

public class ConnectionManager {  

    private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>() {  
        @Override  
        protected Connection initialValue() {  
            Connection conn = null;  
            try {  
                conn = DriverManager.getConnection(  
                        "jdbc:mysql://localhost:3306/test", "username",  
                        "password");  
            } catch (SQLException e) {  
                e.printStackTrace();  
            }  
            return conn;  
        }  
    };  

    public static Connection getConnection() {  
        return connectionHolder.get();  
    }  

    public static void setConnection(Connection conn) {  
        connectionHolder.set(conn);  
    }  
}  

源码 ##

/** 
    * Sets the current thread's copy of this thread-local variable 
    * to the specified value.  Most subclasses will have no need to 
    * override this method, relying solely on the {@link #initialValue} 
    * method to set the values of thread-locals. 
    * 
    * @param value the value to be stored in the current thread's copy of 
    *        this thread-local. 
    */  
   public void set(T value) {  
       Thread t = Thread.currentThread();  
       ThreadLocalMap map = getMap(t);  
       if (map != null)  
           map.set(this, value);  
       else  
           createMap(t, value);  
   }  

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

---

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

/** 
 * Get the map associated with a ThreadLocal. Overridden in 
 * InheritableThreadLocal. 
 * 
 * @param  t the current thread 
 * @return the map 
 */  
ThreadLocalMap getMap(Thread t) {  
    return t.threadLocals;  
}  

/** 
 * Create the map associated with a ThreadLocal. Overridden in 
 * InheritableThreadLocal. 
 * 
 * @param t the current thread 
 * @param firstValue value for the initial entry of the map 
 * @param map the map to store. 
 */  
void createMap(Thread t, T firstValue) {  
    t.threadLocals = new ThreadLocalMap(this, firstValue);  
}  

/** 
 * Returns the value in the current thread's copy of this 
 * thread-local variable.  If the variable has no value for the 
 * current thread, it is first initialized to the value returned 
 * by an invocation of the {@link #initialValue} method. 
 * 
 * @return the current thread's value of this thread-local 
 */  
public T get() {  
    Thread t = Thread.currentThread();  
    ThreadLocalMap map = getMap(t);  
    if (map != null) {  
        ThreadLocalMap.Entry e = map.getEntry(this);  
        if (e != null)  
            return (T)e.value;  
    }  
    return setInitialValue();  
}  

/** 
    * Variant of set() to establish initialValue. Used instead 
    * of set() in case user has overridden the set() method. 
    * 
    * @return the initial value 
    */  
   private T setInitialValue() {  
       T value = initialValue();  
       Thread t = Thread.currentThread();  
       ThreadLocalMap map = getMap(t);  
       if (map != null)  
           map.set(this, value);  
       else  
           createMap(t, value);  
       return value;  
   }  

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

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

小结

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

ConnectionManager.java

package com.test;  

import java.sql.Connection;  
import java.sql.DriverManager;  
import java.sql.SQLException;  

public class ConnectionManager {  

    private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>() {  
        @Override  
        protected Connection initialValue() {  
            Connection conn = null;  
            try {  
                conn = DriverManager.getConnection(  
                        "jdbc:mysql://localhost:3306/test", "username",  
                        "password");  
            } catch (SQLException e) {  
                e.printStackTrace();  
            }  
            return conn;  
        }  
    };  

    public static Connection getConnection() {  
        return connectionHolder.get();  
    }  

    public static void setConnection(Connection conn) {  
        connectionHolder.set(conn);  
    }  
}