[置顶] 线程知识-ThreadLocal使用详解

最近在看Spring的时候回顾了一下ThreadLocal，下面是ThreadLocal的使用说明。

概述

首先，谈到ThreadLocal的使用，我们先来了解一下ThreadLocal是什么？ThreadLocal是在JDK1,2的版本中开始提供的，他不是一个线程，而是一个线程的本地化对象。当某个变量在使用ThreadLocal进行维护时，ThreadLocal为使用该变量的每个线程分配了一个独立的变量副本，每个线程可以自行操作自己对应的变量副本，而不会影响其他线程的变量副本。

从线程的角度看，每个线程都保持一个对其线程局部变量副本的隐式引用，只要线程是活动的并且 ThreadLocal 实例是可访问的；在线程消失之后，其线程局部实例的所有副本都会被垃圾回收（除非存在对这些副本的其他引用）。
 
通过ThreadLocal存取的数据，总是与当前线程相关，也就是说，JVM 为每个运行的线程，绑定了私有的本地实例存取空间，从而为多线程环境常出现的并发访问问题提供了一种隔离机制。
 
ThreadLocal是如何做到为每一个线程维护变量的副本的呢？其实实现的思路很简单，在ThreadLocal类中有一个Map，用于存储每一个线程的变量的副本。

ThreadLocal的API

ThreadLocal的API提供了如下的4个方法，分别是：

 
T get()
          返回此线程局部变量的当前线程副本中的值，如果这是线程第一次调用该方法，则创建并初始化此副本。
 
protected  T initialValue()
          返回此线程局部变量的当前线程的初始值。最多在每次访问线程来获得每个线程局部变量时调用此方法一次，即线程第一次使用 get() 方法访问变量的时候。如果线程先于 get 方法调用 set(T) 方法，则不会在线程中再调用 initialValue 方法。

          

          若该实现只返回 null；如果程序员希望将线程局部变量初始化为 null 以外的某个值，则必须为 ThreadLocal 创建子类，并重写此方法。通常，将使用匿名内部类。initialValue 的典型实现将调用一个适当的构造方法，并返回新构造的对象。

 
void remove()
          移除此线程局部变量的值。这可能有助于减少线程局部变量的存储需求。如果再次访问此线程局部变量，那么在默认情况下它将拥有其 initialValue。
 
void set(T value)
          将此线程局部变量的当前线程副本中的值设置为指定值。许多应用程序不需要这项功能，它们只依赖于 initialValue() 方法来设置线程局部变量的值。
 
在程序中一般都重写initialValue方法，以给定一个特定的初始值。

在上面的概述中也说到，其实ThreadLocal就是Map的一个应用，下面来看一个ThreadLocal实现的简单模拟版本。

ThreadLocal简单模拟实现

package org.lmu.threadlocal;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

public class ThreadLocal<T> {
	private Map<Thread,T> map = Collections.synchronizedMap(new HashMap<Thread, T>());
	  
	/**
	 * 取得线程局部变量的值
	 * @return 线程局部变量的值
	 */
	public T get(){
		Thread currenThread = Thread.currentThread();
		T temp = map.get(currenThread);//取得线程局部变量的值
		if(temp==null&&map.containsKey(currenThread)){
			temp = initialValue();
			map.put(currenThread, temp);
		} 
		return temp;
	}
	
	/**
	 * 设置当前线程局部变量的值
	 * @param value 局部变量需设的值
	 */
	public void set(T value){ 
		map.put(Thread.currentThread(), value);
	}
	
	/**
	 * 将线程局部变量的值删除
	 */
	public void remove(){
		map.remove(Thread.currentThread());
	}
	
	/**
	 * 线程局部变量初始值
	 * @return 初始值为null
	 */
	public T initialValue(){
		return null;
	}
}

ThreadLocal实例 

package org.lmu.threadlocal;

public class ThreadLocalTest {
	//通过覆写ThreadLocal中的initialValue方法为线程局部变量初始化之为0
	ThreadLocal<Integer> tlNum = new ThreadLocal<Integer>(){
 
		protected Integer initialValue() { 
			return 0;
		}
		
	};
	
	/**
	 * 
	 * @return 下一个值
	 */
	public int getNextNum(){
		Integer num = tlNum.get();//取得下一个值
		tlNum.set(num+1);//设置下一个值
		return num;//返回取得的值
	}
	
	private static class TestThread implements Runnable{
		private ThreadLocalTest tlt;
		
		public TestThread(ThreadLocalTest tlt) {
			this.tlt = tlt;
		}
		public void run() {
			int n = 3;
			for (int i = 0; i < n; i++) {
				System.out.println("线程【"+Thread.currentThread().getName()+"】-线程变量值【"+tlt.getNextNum()+"】");
			}
		}
	} 
	
	
	public static void main(String[] args) {
		
		//TestThread tt1 = new TestThread(new ThreadLocalTest());
		//TestThread tt2 = new TestThread(new ThreadLocalTest());
		//TestThread tt3 = new TestThread(new ThreadLocalTest());
  		//之前这样写是不正确的

		ThreadLocalTest tlt = new ThreadLocalTest();
	    TestThread tt1 = new TestThread(tlt);
		TestThread tt2 = new TestThread(tlt);
		TestThread tt3 = new TestThread(tlt);
		Thread t1 = new Thread(tt1);
		Thread t2 = new Thread(tt2);
		Thread t3 = new Thread(tt3);
		t1.start();
		t2.start();
		t3.start();
	}
}

上面的例子中使用ThreadLocal来维护数值变量，初始值设置为0，,并在线程实现中打印3个序列值，这里提供3个线程进行测试，下面是测试的结果。

线程【Thread-2】-线程变量值【0】
线程【Thread-1】-线程变量值【0】
线程【Thread-0】-线程变量值【0】
线程【Thread-1】-线程变量值【1】
线程【Thread-2】-线程变量值【1】
线程【Thread-1】-线程变量值【2】
线程【Thread-0】-线程变量值【1】
线程【Thread-0】-线程变量值【2】
线程【Thread-2】-线程变量值【2】

从结果中可以看到，每个线程都可以独立的操作对应的副本，不会出现相互干扰的情况。

ThreadLocal与Thread同步机制的比较

在同步机制中，通过对象所机制保证同一个时间只能有一个线程访问变量。而ThreadLocal则从列一个角度来解决多线程的并发访问。

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