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

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

 

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

 

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

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());

		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则从列一个角度来解决多线程的并发访问。

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