ThreadLocal 使用分析

1.概述

       ThreadLocal是什么呢？其实ThreadLocal并非是一个线程的本地实现版本，它并不是一个Thread，而是threadlocalvariable(线程局部变量)。也许把它命名为ThreadLocalVar更加合适。线程局部变量(ThreadLocal)其实的功用非常简单，就是为每一个使用该变量的线程都提供一个变量值的副本，是Java中一种较为特殊的线程绑定机制，是每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。

      从线程的角度看，每个线程都保持一个对其线程局部变量副本的隐式引用，只要线程是活动的并且 ThreadLocal实例是可访问的；在线程消失之后，其线程局部实例的所有副本都会被垃圾回收（除非存在对这些副本的其他引用）。

      通过ThreadLocal存取的数据，总是与当前线程相关，也就是说，JVM为每个运行的线程，绑定了私有的本地实例存取空间，从而为多线程环境常出现的并发访问问题提供了一种隔离机制。

      ThreadLocal是如何做到为每一个线程维护变量的副本的呢？其实实现的思路很简单，在ThreadLocal类中有一个Map，用于存储每一个线程的变量的副本。

       概括起来说，对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。

2. 使用方法

import java.util.Random;

/**
 * ThreadLocal使用过程
 * 1.创建一个ThreadLocal的实例对象,用于保存线程间需要隔离处理的对象
 * 2.创建get*** 获取对象的方法，如下getStudent()
 * 3.线程的run方法中，利用get***获取对象，操作此对象即可
 * 或者
 * 2.重写initialValue方法设置初始值
 * 3.tLocal.get***来获取最初对象
 * @author ISC1
 *
 */
public class threadlocaltest implements Runnable {

	ThreadLocal<Student> studentLocal = new ThreadLocal<Student>();
	
	// ①通过匿名内部类覆盖ThreadLocal的initialValue()方法，指定初始值  
	ThreadLocal<Student> tLocal = new ThreadLocal<Student>(){
		@Override 
		protected Student initialValue(){
			Student s = new Student(10);
			return s;			
		}
	};
	
//	public Student getStudent() {
//		Student s = (Student) studentLocal.get();
//		if (s == null) {
//			s = new Student();
//			studentLocal.set(s);
//		}
//		return s;
//	}

	public static void main(String[] args) {
		threadlocaltest t = new threadlocaltest();
		new Thread(t, "t1").start();
		new Thread(t, "t2").start();
	}

	private void accessStudent() {
//		Student s =this.getStudent();
		Student s = tLocal.get();
		Random random = new Random();
		int age = random.nextInt(100);
		System.out.println("current thread set age " + Thread.currentThread()
				+ ":" + age);
		s.setAge(age);
		System.out.println("current thread first get age "
				+ Thread.currentThread() + ":" + s.getAge());
		try {
			Thread.sleep(500);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("current thread second get age "
				+ Thread.currentThread() + ":" + s.getAge());
	}



	class Student {
		Student(int age){
			this.age=age;
		}
		Student(){}
		private int age;

		public int getAge() {
			return age;
		}

		public void setAge(int age) {
			this.age += age;
		}

	}

	@Override
	public void run() {
		accessStudent();

	}
}<span style="color:#cc0000;">
</span>

代码中有注解，这里级不多做解释，注释部分非无用，而是第一种实现方式，两种都可以~源程序源自网络。

参考链接：传送门

　　总结一下：

　　1）实际的通过ThreadLocal创建的副本是存储在每个线程自己的threadLocals中的；

　　2）为何threadLocals的类型ThreadLocalMap的键值为ThreadLocal对象，因为每个线程中可有多个threadLocal变量，就像上面代码中的longLocal和stringLocal；

　　3）在进行get之前，必须先set，否则会报空指针异常；

　　    如果想在get之前不需要调用set就能正常访问的话，必须重写initialValue()方法。

　　　 因为在上面的代码分析过程中，我们发现如果没有先set的话，即在map中查找不到对应的存储，则会通过调用setInitialValue方法返回i，而在setInitialValue方法中，有一个语句是T value = initialValue()， 而默认情况下，initialValue方法返回的是null。

3. 原理简介

　    

     get()方法是用来获取ThreadLocal在当前线程中保存的变量副本，set()用来设置当前线程中变量的副本，remove()用来移除当前线程中变量的副本，initialValue()是一个protected方法，一般是用来在使用时进行重写的，它是一个延迟加载方法，

      首先，在每个线程Thread内部有一个ThreadLocal.ThreadLocalMap类型的成员变量threadLocals，这个threadLocals就是用来存储实际的变量副本的，键值为当前ThreadLocal变量，value为变量副本（即T类型的变量）。

　　初始时，在Thread里面，threadLocals为空，当通过ThreadLocal变量调用get()方法或者set()方法，就会对Thread类中的threadLocals进行初始化，并且以当前ThreadLocal变量为键值，以ThreadLocal要保存的副本变量为value，存到threadLocals。

　　然后在当前线程里面，如果要使用副本变量，就可以通过get方法在threadLocals里面查找。

     源码分析参见链接

        

4. 内存泄露问题  <原文见>

       threadlocal里面使用了一个存在弱引用的map,当释放掉threadlocal的强引用以后,map里面的value却没有被回收.而这块value永远不会被访问到了. 所以存在着内存泄露. 最好的做法是将调用threadlocal的remove方法.

　　在threadlocal的生命周期中,都存在这些引用. 看下图: 实线代表强引用,虚线代表弱引用.

 

       每个thread中都存在一个map, map的类型是ThreadLocal.ThreadLocalMap. Map中的key为一个threadlocal实例. 这个Map的确使用了弱引用,不过弱引用只是针对key. 每个key都弱引用指向threadlocal. 当把threadlocal实例置为null以后,没有任何强引用指向threadlocal实例,所以threadlocal将会被gc回收. 但是,我们的value却不能回收,因为存在一条从current thread连接过来的强引用. 只有当前thread结束以后, current thread就不会存在栈中,强引用断开, Current Thread, Map, value将全部被GC回收.

　　所以得出一个结论就是只要这个线程对象被gc回收，就不会出现内存泄露，但在threadLocal设为null和线程结束这段时间不会被回收的，就发生了我们认为的内存泄露。其实这是一个对概念理解的不一致，也没什么好争论的。最要命的是线程对象不被回收的情况，这就发生了真正意义上的内存泄露。比如使用线程池的时候，线程结束是不会销毁的，会再次使用的。就可能出现内存泄露。　　

　　PS.Java为了最小化减少内存泄露的可能性和影响，在ThreadLocal的get,set的时候都会清除线程Map里所有key为null的value。所以最怕的情况就是，threadLocal对象设null了，开始发生“内存泄露”，然后使用线程池，这个线程结束，线程放回线程池中不销毁，这个线程一直不被使用，或者分配使用了又不再调用get,set方法，那么这个期间就会发生真正的内存泄露。<>

最常见的ThreadLocal使用场景为 用来解决 数据库连接、Session管理、日期格式化等。