最近在看Spring的时候回顾了一下ThreadLocal,下面是ThreadLocal的使用说明。
概述
首先,谈到ThreadLocal的使用,我们先来了解一下ThreadLocal是什么?ThreadLocal是在JDK1,2的版本中开始提供的,他不是一个线程,而是一个线程的本地化对象。当某个变量在使用ThreadLocal进行维护时,ThreadLocal为使用该变量的每个线程分配了一个独立的变量副本,每个线程可以自行操作自己对应的变量副本,而不会影响其他线程的变量副本。
从线程的角度看,每个线程都保持一个对其线程局部变量副本的隐式引用,只要线程是活动的并且 ThreadLocal 实例是可访问的;在线程消失之后,其线程局部实例的所有副本都会被垃圾回收(除非存在对这些副本的其他引用)。
通过ThreadLocal存取的数据,总是与当前线程相关,也就是说,JVM 为每个运行的线程,绑定了私有的本地实例存取空间,从而为多线程环境常出现的并发访问问题提供了一种隔离机制。
ThreadLocal是如何做到为每一个线程维护变量的副本的呢?其实实现的思路很简单,在ThreadLocal类中有一个Map,用于存储每一个线程的变量的副本。
通过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();
- }
- }
线程【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】
线程【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采用了“以空间换时间”的方式。前者仅提供一份变量,让不同的线程排队访问,而后者为每一个线程都提供了一份变量,因此可以同时访问而互不影响。