ThreadLocal类深刻理解

synchronized这类线程同步的机制可以解决多线程并发问题，在这种解决方案下，多个线程访问到的，都是同一份变量的内容。为了防止在多线程访问的过程中，可能会出现的并发错误。不得不对多个线程的访问进行同步，这样也就意味着，多个线程必须先后对变量的值进行访问或者修改，这是一种以延长访问时间来换取线程安全性的策略。而ThreadLocal类为每一个线程都维护了自己独有的变量拷贝。每个线程都拥有了自己独立的一个变量，竞争条件被彻底消除了，那就没有任何必要对这些线程进行同步，它们也能最大限度的由CPU调度，并发执行。并且由于每个线程在访问该变量时，读取和修改的，都是自己独有的那一份变量拷贝，变量被彻底封闭在每个访问的线程中，并发错误出现的可能也完全消除了。对比前一种方案，这是一种以空间来换取线程安全性的策略。主要方法如下：ThreadLocal()创建一个线程本地变量。T get()返回此线程局部变量的当前线程副本中的值，如果这是线程第一次调用该方法，则创建并初始化此副本。protected T initialValue()返回此线程局部变量的当前线程的初始值。最多在每次访问线程来获得每个线程局部变量时调用此方法一次，即线程第一次使用 get() 方法访问变量的时候。如果线程先于 get 方法调用 set(T) 方法，则不会在线程中再调用 initialValue 方法。若该实现只返回 null；如果程序员希望将线程局部变量初始化为 null 以外的某个值，则必须为 ThreadLocal 创建子类，并重写此方法。通常，将使用匿名内部类。initialValue 的典型实现将调用一个适当的构造方法，并返回新构造的对象。void remove()移除此线程局部变量的值。这可能有助于减少线程局部变量的存储需求。如果再次访问此线程局部变量，那么在默认情况下它将拥有其 initialValue。void set(T value)将此线程局部变量的当前线程副本中的值设置为指定值。许多应用程序不需要这项功能，它们只依赖于 initialValue() 方法来设置线程局部变量的值。在程序中一般都重写initialValue方法，以给定一个特定的初始值。典型实例：1、Hiberante的Session 工具类HibernateUtil这个类是Hibernate官方文档中HibernateUtil类，用于session管理。public class HibernateUtil{private static Log log = LogFactory.getLog(HibernateUtil.class);private static final SessionFactory sessionFactory; //定义SessionFactorystatic {try {// 通过默认配置文件hibernate.cfg.xml创建SessionFactorysessionFactory = new Configuration().configure().buildSessionFactory();}catch (Throwable ex) {log.error("初始化SessionFactory失败！",ex);throw new ExceptionInInitializerError(ex);}}//创建线程局部变量session，用来保存Hibernate的Sessionpublic static final ThreadLocal session = new ThreadLocal();/*** 获取当前线程中的Session* @return Session* @throws HibernateException*/public static Session currentSession() throws HibernateException {Session s = (Session) session.get();// 如果Session还没有打开，则新开一个Sessionif (s == null) {s = sessionFactory.openSession();session.set(s); //将新开的Session保存到线程局部变量中}return s;}public static void closeSession() throws HibernateException {//获取线程局部变量，并强制转换为Session类型Session s = (Session) session.get();session.set(null);if (s != null)s.close();}}在这个类中，由于没有重写ThreadLocal的initialValue()方法，则首次创建线程局部变量session其初始值为null，第一次调用currentSession()的时候，线程局部变量的get()方法也为null。因此，对session做了判断，如果为null，则新开一个Session，并保存到线程局部变量session中，这一步非常的关键，这也是“publicstatic final ThreadLocal session = new ThreadLocal()”所创建对象session能强制转换为Hibernate Session对象的原因。2、创建一个Bean，通过不同的线程对象设置Bean属性，保证各个线程Bean对象的独立性。/*** 学生*/public class Student {private int age = 0; //年龄public int getAge() {return this.age;}public void setAge(int age) {this.age = age;}}/*** 多线程下测试程序*/public class ThreadLocalDemo implements Runnable {//创建线程局部变量studentLocal，在后面你会发现用来保存Student对象private final static ThreadLocal studentLocal = new ThreadLocal();public static void main(String[] agrs) {ThreadLocalDemo td = new ThreadLocalDemo();Thread t1 = new Thread(td,"a");Thread t2 = new Thread(td,"b");t1.start();t2.start();}public void run() {accessStudent();}/*** 示例业务方法，用来测试*/public void accessStudent() {//获取当前线程的名字String currentThreadName = Thread.currentThread().getName();System.out.println(currentThreadName + " is running!");//产生一个随机数并打印Random random = new Random();int age = random.nextInt(100);System.out.println("thread " + currentThreadName + " set age to:" + age);//获取一个Student对象，并将随机数年龄插入到对象属性中Student student = getStudent();student.setAge(age);System.out.println("thread " + currentThreadName + " first read age is:" + student.getAge());try {Thread.sleep(500);}catch (InterruptedException ex) {ex.printStackTrace();}System.out.println("thread " + currentThreadName + " second read age is:" + student.getAge());}protected Student getStudent() {//获取本地线程变量并强制转换为Student类型Student student = (Student) studentLocal.get();//线程首次执行此方法的时候，studentLocal.get()肯定为nullif (student == null) {//创建一个Student对象，并保存到本地线程变量studentLocal中student = new Student();studentLocal.set(student);}return student;}}运行结果：a is running!thread a set age to:76b is running!thread b set age to:27thread a first read age is:76thread b first read age is:27thread a second read age is:76thread b second read age is:27可以看到a、b两个线程age在不同时刻打印的值是完全相同的。这个程序通过妙用ThreadLocal，既实现多线程并发，游兼顾数据的安全性。3、数据库连接管理

public class ConnectionManager {

06

07	private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>() {

08

@Override

09	protected Connection initialValue() {

10	Connection conn = null ;

11

try {

12	conn = DriverManager.getConnection(

13	"jdbc:mysql://localhost:3306/test" , "username" ,

14	"password" );

15	} catch (SQLException e) {

16	e.printStackTrace();

17

}

18	return conn;

19

}

20

};

21

22	public static Connection getConnection() {

23	return connectionHolder.get();

24

}

25

26	public static void setConnection(Connection conn) {

27	connectionHolder.set(conn);

28

}

29

}

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

01

/**

02	*Sets the current thread's copy of this thread-local variable

03	*to the specified value. Most subclasses will have no need to

04	*override this method,relying solely on the {@link #initialValue}

05	*method to set the values of thread-locals.

06

*

07	*@param value the value to be stored in the current thread's copy of

08	*this thread-local.

09

*/

10	public void set(Tvalue) {

11	Threadt = Thread.currentThread();

12	ThreadLocalMapmap = 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方法的实现：

1	ThreadLocalMapgetMap(Thread t) {

2	return t.threadLocals;

3

}

1	void createMap(Threadt,T firstValue) {

2	t.threadLocals= new ThreadLocalMap( this ,firstValue);

3

}

代码已经说的非常直白，就是获取和设置Thread内的一个叫threadLocals的变量，而这个变量的类型就是ThreadLocalMap，这样进一步验证了上文中的观点：每个线程都有自己独立的ThreadLocalMap对象。打开java.lang.Thread类的源代码，我们能得到更直观的证明：

1	/*ThreadLocal values pertaining to this thread. This map is maintained

2	*by the ThreadLocal class. */

3	ThreadLocal.ThreadLocalMapthreadLocals = null ;

那么接下来再看一下ThreadLocal类中的get()方法，代码是这么说的：viewsourceprint?

01

/**

02	*Returns the value in the current thread's copy of this

03	*thread-local variable. If the variable has no value for the

04	*current thread,it is first initialized to the value returned

05	*by an invocation of the {@link #initialValue}method.

06

*

07	*@return the current thread's value of this thread-local

08

*/

09	public Tget() {

10	Threadt = Thread.currentThread();

11	ThreadLocalMapmap = getMap(t);

12	if (map!= null ){

13	ThreadLocalMap.Entrye = map.getEntry( this );

14	if (e!= null )

15	return (T)e.value;

16

}

17	return setInitialValue();

18

}

19

20

/**

21	*Variant of set() to establish initialValue. Used instead

22	*of set() in case user has overridden the set() method.

23

*

24	*@return the initial value

25

*/

26	private TsetInitialValue() {

27	Tvalue = initialValue();

28	Threadt = Thread.currentThread();

29	ThreadLocalMapmap = getMap(t);

30	if (map!= null )

31	map.set( this ,value);

32

else

33	createMap(t,value);

34	return value;

35

}

这两个方法的代码告诉我们，在获取和当前线程绑定的值时，ThreadLocalMap对象是以this指向的ThreadLocal对象为键进行查找的，这当然和前面set()方法的代码是相呼应的。进一步地，我们可以创建不同的ThreadLocal实例来实现多个变量在不同线程间的访问隔离，为什么可以这么做？因为不同的ThreadLocal对象作为不同键，当然也可以在线程的ThreadLocalMap对象中设置不同的值了。通过ThreadLocal对象，在多线程中共享一个值和多个值的区别，就像你在一个HashMap对象中存储一个键值对和多个键值对一样，仅此而已。设置到这些线程中的隔离变量，会不会导致内存泄漏呢？ThreadLocalMap对象保存在Thread对象中，当某个线程终止后，存储在其中的线程隔离的变量，也将作为Thread实例的垃圾被回收掉，所以完全不用担心内存泄漏的问题。在多个线程中隔离的变量，光荣的生，合理的死，真是圆满，不是么？最后再提一句，ThreadLocal变量的这种隔离策略，也不是任何情况下都能使用的。如果多个线程并发访问的对象实例只允许，也只能创建那么一个，那就没有别的办法了，老老实实的使用同步机制来访问吧。总结：ThreadLocal使用场合主要解决多线程中数据数据因并发产生不一致问题。ThreadLocal为每个线程的中并发访问的数据提供一个副本，通过访问副本来运行业务，这样的结果是耗费了内存，单大大减少了线程同步所带来性能消耗，也减少了线程并发控制的复杂度。ThreadLocal不能使用原子类型，只能使用Object类型。ThreadLocal的使用比synchronized要简单得多。ThreadLocal和Synchonized都用于解决多线程并发访问。但是ThreadLocal与synchronized有本质的区别。synchronized是利用锁的机制，使变量或代码块在某一时该只能被一个线程访问。而ThreadLocal为每一个线程都提供了变量的副本，使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。而Synchronized却正好相反，它用于在多个线程间通信时能够获得数据共享。Synchronized用于线程间的数据共享，而ThreadLocal则用于线程间的数据隔离。当然ThreadLocal并不能替代synchronized,它们处理不同的问题域。Synchronized用于实现同步机制，比ThreadLocal更加复杂。ThreadLocal使用的一般步骤1、在多线程的类（如ThreadDemo类）中，创建一个ThreadLocal对象threadXxx，用来保存线程间需要隔离处理的对象xxx。2、在ThreadDemo类中，创建一个获取要隔离访问的数据的方法getXxx()，在方法中判断，若ThreadLocal对象为null时候，应该new()一个隔离访问类型的对象，并强制转换为要应用的类型。3、在ThreadDemo类的run()方法中，通过getXxx()方法获取要操作的数据，这样可以保证每个线程对应一个数据对象，在任何时刻都操作的是这个对象。