理解Java ThreadLocal

    ThreadLocal若是单纯从名字上来看像是“本地线程"这么个意思，只能说这个名字起的确实不太好，很容易让人产生误解，ThreadLocalVariable（线程本地变量）应该是个更好的名字。咱们先看一下官方对ThreadLocal的描述：

该类提供了线程局部 (thread-local) 变量。这些变量不一样于它们的普通对应物，由于访问某个变量（经过其 get 或 set 方法）的每一个线程都有本身的局部变量，它独立于变量的初始化副本。ThreadLocal 实例一般是类中的 private static 字段，它们但愿将状态与某一个线程（例如，用户 ID 或事务 ID）相关联。

咱们从中摘出要点：

    一、每一个线程都有本身的局部变量

    每一个线程都有一个独立于其余线程的上下文来保存这个变量，一个线程的本地变量对其余线程是不可见的（有前提，后面解释）

    二、独立于变量的初始化副本

    ThreadLocal能够给一个初始值，而每一个线程都会得到这个初始化值的一个副本，这样才能保证不一样的线程都有一份拷贝。

    三、状态与某一个线程相关联

    ThreadLocal 不是用于解决共享变量的问题的，不是为了协调线程同步而存在，而是为了方便每一个线程处理本身的状态而引入的一个机制，理解这点对正确使用ThreadLocal相当重要。

咱们先看一个简单的例子：

public class ThreadLocalTest {
        
        //建立一个Integer型的线程本地变量
	public static final ThreadLocal<Integer> local = new ThreadLocal<Integer>() {
		@Override
		protected Integer initialValue() {
			return 0;
		}
	};
	public static void main(String[] args) throws InterruptedException {
		Thread[] threads = new Thread[5];
		for (int j = 0; j < 5; j++) {		
               threads[j] = new Thread(new Runnable() {
				@Override
				public void run() {
                                        //获取当前线程的本地变量，而后累加5次
					int num = local.get();
					for (int i = 0; i < 5; i++) {
						num++;
					}
                                        //从新设置累加后的本地变量
					local.set(num);
					System.out.println(Thread.currentThread().getName() + " : "+ local.get());

				}
			}, "Thread-" + j);
		}

		for (Thread thread : threads) {
			thread.start();
		}
	}
}

运行后结果：

Thread-0 : 5
Thread-4 : 5
Thread-2 : 5
Thread-1 : 5
Thread-3 : 5

    咱们看到，每一个线程累加后的结果都是5，各个线程处理本身的本地变量值，线程之间互不影响。

    咱们再来看一个例子：

public class ThreadLocalTest {
	private static Index num = new Index();
        //建立一个Index类型的本地变量 
	private static ThreadLocal<Index> local = new ThreadLocal<Index>() {
		@Override
		protected Index initialValue() {
			return num;
		}
	};

	public static void main(String[] args) throws InterruptedException {
		Thread[] threads = new Thread[5];
		for (int j = 0; j < 5; j++) {
			threads[j] = new Thread(new Runnable() {
				@Override
				public void run() {
                                        //取出当前线程的本地变量，并累加1000次
					Index index = local.get();
					for (int i = 0; i < 1000; i++) {                                          
						index.increase();
					}
					System.out.println(Thread.currentThread().getName() + " : "+ index.num);

				}
			}, "Thread-" + j);
		}
		for (Thread thread : threads) {
			thread.start();
		}
	}

	static class Index {
		int num;

		public void increase() {
			num++;
		}
	}
}

执行后咱们发现结果以下（每次运行还都不同）：

Thread-0 : 1390
Thread-2 : 2390
Thread-4 : 4390
Thread-3 : 3491
Thread-1 : 1390

    为何线程本地变量又失效了呢？你们能够仔细观察上面代码本身先找一下缘由。

-----------------------------------------------低调的分割线-------------------------------------------

    让咱们再来回味一下 “ThreadLocal能够给一个初始值，而每一个线程都会得到这个初始化值的一个副本” 这句话。“初始值的副本。。。”，貌似想起点什么。咱们再来看一下上面代码中定义ThreadLocal的地方

private static Index num = new Index();
	private static ThreadLocal<Index> local = new ThreadLocal<Index>() {
		@Override
		protected Index initialValue() {
			return num;       // 注意这里，返回的是已经定义好的对象num，而不是new Index()
		}
	};

    上面代码中，咱们经过覆盖initialValue函数来给咱们的ThreadLocal提供初始值，每一个线程都会获取这个初始值的一个副本。而如今咱们的初始值是一个定义好的一个对象，num是这个对象的引用.换句话说咱们的初始值是一个引用。引用的副本和引用指向的不就是同一个对象吗？

    若是咱们想给每个线程都保存一个Index对象应该怎么办呢？那就是建立对象的副本而不是对象引用的副本：

private static ThreadLocal<Index> local = new ThreadLocal<Index>() {
		@Override
		protected Index initialValue() {
			return new Index(); //注意这里
		}
	};

对象的拷贝图示：

    如今咱们应该能明白ThreadLocal本地变量的含义了吧。接下来咱们就来看看ThreadLocal的源码，从内部来揭示它的神秘面纱。

    ThreadLocal有一个内部类ThreadLocalMap,这个类的实现占了整个ThreadLocal类源码的一多半。这个ThreadLocalMap的做用很是关键，它就是线程真正保存线程本身本地变量的容器。每个线程都有本身的单独的一个ThreadLocalMap实例，其全部的本地变量都会保存到这一个map中。如今就让咱们从ThreadLocal的get和set这两个最经常使用的方法开始分析：

public T get() {
    //获取当前执行线程
    Thread t = Thread.currentThread();
    //取得当前线程的ThreadLocalMap实例
    ThreadLocalMap map = getMap(t);
    //若是map不为空，说明该线程已经有了一个ThreadLocalMap实例
    if (map != null) {
        //map中保存线程的全部的线程本地变量，咱们要去查找当前线程本地变量
        ThreadLocalMap.Entry e = map.getEntry(this);
        //若是当前线程本地变量存在这个map中，则返回其对应的值
        if (e != null)
            return (T)e.value;
    }
    //若是map不存在或者map中不存在当前线程本地变量，返回初始值
    return setInitialValue();
}

强调一下：Thread对象都有一个ThreadLocalMap类型的属性threadLocals，这个属性是专门用于保存本身全部的线程本地变量的。这个属性在线程对象初始化的时候为null。因此对一个线程对象第一次使用线程本地变量的时候，须要对这个threadLocals属性进行初始化操做。注意要区别 “线程第一次使用本地线程变量”和“第一次使用某一个线程本地线程变量”。

getMap方法:

//直接返回线程对象的threadLocals属性
ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

setInitialValue方法：（看完后再回顾一下以前的那个例子）

private T setInitialValue() {
    //获取初始化值，initialValue 就是咱们以前覆盖的方法
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    //若是map不为空，将初始化值放入到当前线程的ThreadLocalMap对象中
    if (map != null)
        map.set(this, value);
    else
        //当前线程第一次使用本地线程变量，须要对map进行初始化工做
        createMap(t, value);
    //返回初始化值
    return value;
}

咱们再来看一下set方法

public void set(T value) {
     Thread t = Thread.currentThread();
     ThreadLocalMap map = getMap(t);

     if (map != null)
         map.set(this, value);
     //说明线程第一次使用线程本地变量(注意这里的第一次含义)
     else
         createMap(t, value);
 }

ThradLocal还有一个remove方法，让咱们来分析一下:

public void remove() {
     //获取当前线程的ThreadLocalMap对象
     ThreadLocalMap m = getMap(Thread.currentThread());
     //若是map不为空，则删除该本地变量的值
     if (m != null)
         m.remove(this);
 }

    到这里你们应该对ThreadLocal变量比较清晰了，至于ThradLocalMap的实现细节这里就不在说了。你们有兴趣能够本身去看ThreadLocal的源码。