java ThreadLocal(应用场景及使用方式及原理)

Posted 2020-09-26 yxysuanfa

尽管ThreadLocal与并发问题相关，可是很多程序猿只将它作为一种用于“方便传參”的工具，胖哥觉得这或许并非ThreadLocal设计的目的，它本身是为线程安全和某些特定场景的问题而设计的。
ThreadLocal是什么呢。
每一个ThreadLocal能够放一个线程级别的变量，可是它本身能够被多个线程共享使用，并且又能够达到线程安全的目的，且绝对线程安全。
比如：

public final static ThreadLocal<String> RESOURCE = new ThreadLocal<String>();

RESOURCE代表一个能够存放String类型的ThreadLocal对象。此时不论什么一个线程能够并发訪问这个变量，对它进行写入、读取操作，都是线程安全的。比方一个线程通过RESOURCE.set(“aaaa”);将数据写入ThreadLocal中，在不论什么一个地方，都能够通过RESOURCE.get();将值获取出来。
可是它也并不完美，有很多缺陷，就像大家依赖于它来做參数传递一样。接下来我们就来分析它的一些不好的地方。
为什么有些时候会将ThreadLocal作为方便传递參数的方式呢？比如当很多方法相互调用时，最初的设计可能没有想太多，有多少个參数就传递多少个变量，那么整个參数传递的过程就是零散的。进一步思考：若A方法调用B方法传递了8个參数。B方法接下来调用C方法->D方法->E方法->F方法等仅仅须要5个參数，此时在设计API时就涉及5个參数的入口。这些方法在业务发展的过程中被很多地方所复用。
某一天。我们发现F方法须要加一个參数，这个參数在A方法的入口參数中有，此时，假设要改中间方法牵涉面会非常大。并且不知道改动后会不会有Bug。

作为程序猿的我们可能会随性一想，ThreadLocal反正是全局的，就放这里吧。确实好解决。
可是此时你会发现系统中这样的方式有点像在贴补丁。越贴越多，我们必需要求调用相关的代码都使用ThreadLocal传递这个參数，有可能会搞得乱七八糟的。换句话说，并非不让用。而是我们要明白它的入口和出口是可控的。
诡异的ThreadLocal最难琢磨的是“作用域”，尤其是在代码设计之初非常乱的情况下，假设再添加很多ThreadLocal。系统就会逐渐变成神龙见首不见尾的情况。有了这样一个省事的东西。可能很多小伙伴更加不在意设计，由于大家都觉得这些问题都能够通过变化的手段来解决。胖哥觉得这是一种恶性循环。
对于这类业务场景。应当提前有所准备。须要粗粒度化业务模型。即使要用ThreadLocal，也不是加一个參数就加一个ThreadLocal变量。比如，我们能够设计几种对象来封装入口參数，在接口设计时入口參数都以对象为基础。

或许一个类无法表达全部的參数意思，并且那样easy导致强耦合。
通常我们依照业务模型分解为几大类型对象作为它们的參数包装，而且将依照对象属性共享情况进行抽象，在继承关系的每个层次各自扩展对应的參数，或者说加參数就在对象中加，共享參数就在父类中定义，这种參数就逐步规范化了。
我们回到正题，探讨一下ThreadLocal究竟是用来做什么的？为此我们探讨下文中的几个话题。

（1）应用场景及使用方式

为了说明ThreadLocal的应用场景。我们来看一个框架的样例。Spring的事务管理器通过AOP切入业务代码，在进入业务代码前，会依据相应的事务管理器提取出相应的事务对象，假如事务管理器是DataSourceTransactionManager，就会从DataSource中获取一个连接对象，通过一定的包装后将其保存在ThreadLocal中。而且Spring也将DataSource进行了包装，重写了当中的getConnection()方法，或者说该方法的返回将由Spring来控制，这样Spring就能让线程内多次获取到的Connection对象是同一个。
为什么要放在ThreadLocal里面呢？由于Spring在AOP后并不能向应用程序传递參数。应用程序的每一个业务代码是事先定义好的，Spring并不会要求在业务代码的入口參数中必须编写Connection的入口參数。此时Spring选择了ThreadLocal，通过它保证连接对象始终在线程内部，不论什么时候都能拿到，此时Spring很清楚什么时候回收这个连接，也就是很清楚什么时候从ThreadLocal中删除这个元素（在9.2节中会具体解说）。

从Spring事务管理器的设计上能够看出。Spring利用ThreadLocal得到了一个非常完美的设计思路，同一时候它在设计时也十分清楚ThreadLocal中元素应该在什么时候删除。由此，我们简单地觉得ThreadLocal尽量使用在一个全局的设计上。而不是一种打补丁的间接方法。
了解了基本应用场景后，接下来看一个样例。定义一个类用于存放静态的ThreadLocal对象，通过多个线程并行地对ThreadLocal对象进行set、get操作，并将值进行打印。来看看每一个线程自己设置进去的值和取出来的值是否是一样的。

代码例如以下：
代码清单5-8 简单的ThreadLocal样例

public class ThreadLocalTest {

	static class ResourceClass {

		public final static ThreadLocal<String> RESOURCE_1 =
									   new ThreadLocal<String>();

		public final static ThreadLocal<String> RESOURCE_2 =
									   new ThreadLocal<String>();

	}

	static class A {

		public void setOne(String value) {
			ResourceClass.RESOURCE_1.set(value);
		}

		public void setTwo(String value) {
			ResourceClass.RESOURCE_2.set(value);
		}
	}

	static class B {
		public void display() {
			System.out.println(ResourceClass.RESOURCE_1.get()
						+ ":" + ResourceClass.RESOURCE_2.get());
		}
	}

	public static void main(String []args) {
		final A a = new A();
		final B b = new B();
		for(int i = 0 ; i < 15 ; i ++) {
			final String resouce1 = "线程-" + I;
			final String resouce2 = " value = (" + i + ")";
			new Thread() {
				public void run() {
				try {
					a.setOne(resouce1);
					a.setTwo(resouce2);
					b.display();
				}finally {
					ResourceClass.RESOURCE_1.remove();
					ResourceClass.RESOURCE_2.remove();
				}
			}
		}.start();
		}
	}
}

关于这段代码，我们先说几点。

◎ 定义了两个ThreadLocal变量。终于的目的就是要看最后两个值能否相应上。这样才有机会证明ThreadLocal所保存的数据可能是线程私有的。

◎ 使用两个内部类仅仅是为了使測试简单，方便大家直观理解，大家也能够将这个样例的代码拆分到多个类中，得到的结果是同样的。
◎ 測试代码更像是为了方便传递參数。由于它确实传递參数非常方便，但这不过为了測试。
◎ 在finally里面有remove()操作，是为了清空数据而使用的。

为何要清空数据，在后文中会继续介绍细节。

測试结果例如以下：
线程-6: value = (6)
线程-9: value = (9)
线程-0: value = (0)
线程-10: value = (10)
线程-12: value = (12)
线程-14: value = (14)
线程-11: value = (11)
线程-3: value = (3)
线程-5: value = (5)
线程-13: value = (13)
线程-2: value = (2)
线程-4: value = (4)
线程-8: value = (8)
线程-7: value = (7)
线程-1: value = (1)
大家能够看到输出的线程顺序并不是最初定义线程的顺序，理论上能够说明多线程应当是并发运行的，可是依旧能够保持每一个线程里面的值是相应的，说明这些值已经达到了线程私有的目的。
不是说共享变量无法做到线程私有吗？它又是怎样做到线程私有的呢？这就须要我们知道一点点原理上的东西。否则用起来也没那么放心，请看以下的介绍。

（2）ThreadLocal内在原理

从前面的操作能够发现，ThreadLocal最常见的操作就是set、get、remove三个动作。以下来看看这三个动作究竟做了什么事情。首先看set操作，源代码片段如图5-5所看到的。

图5-5 ThreadLcoal.set源代码片段
图5-5中的第一条代码取出了当前线程t。然后调用getMap(t)方法时传入了当前线程，换句话说。该方法返回的ThreadLocalMap和当前线程有点关系，我们先记录下来。

进一步判定假设这个map不为空。那么设置到Map中的Key就是this。值就是外部传入的參数。这个this是什么呢？就是定义的ThreadLocal对象。

代码中有两条路径须要追踪，各自是getMap(Thread)和createMap(Thread , T)。首先来看看getMap(t)操作。如图5-6所看到的。

图5-6 getMap(Thread)操作

在这里。我们看到ThreadLocalMap事实上就是线程里面的一个属性，它在Thread类中的定义是：
ThreadLocal.ThreadLocalMap threadLocals = null;
这样的方法非常easy让人混淆，由于这个ThreadLocalMap是ThreadLocal里面的内部类。放在了Thread类里面作为一个属性而存在。ThreadLocal本身成为这个Map里面存放的Key，用户输入的值是Value。

太乱了。理不清楚了，画个图来看看（见图5-7）。
简单来讲，就是这个Map对象在Thread里面作为私有的变量而存在，所以是线程安全的。ThreadLocal通过Thread.currentThread()获取当前的线程就能得到这个Map对象。同一时候将自身作为Key发起写入和读取，因为将自身作为Key，所以一个ThreadLocal对象就能存放一个线程中相应的Java对象。通过get也自然能找到这个对象。

图5-7 Thread与ThreadLocal的伪代码关联关系

假设还没有理解，则能够将思维放宽一点。

当定义变量String a时，这个“a”事实上仅仅是一个名称（在第3章中已经说到了常量池），虚拟机须要通过符号表来找到对应的信息，而这样的方式正好就像一种K-V结构，底层的处理方式也确实非常接近这样。这里的处理方式是显式地使用Map来存放数据，这也是一种实现手段的变通。
如今有了思路。继续回到上面的话题，为了验证前面的判断和理解，来看看createMap方法的细节，如图5-8所看到的。

图5-8 createMap操作
这段代码是运行一个创建新的Map的操作。而且将第一个值作为这个Map的初始化值，因为这个Map是线程私有的。不可能有还有一个线程同一时候也在对它做put操作，因此这里的赋值和初始化是绝对线程安全的，也同一时候保证了每个外部写入的值都将写入到Map对象中。
最后来看看get()、remove()代码，也许看到这里就能够认定我们的理论是正确的。如图5-9所看到的。

图5-9 get()/remove()方法的代码片段
给我们的感觉是，这样实现是一种技巧，而不是一种技术。

事实上是技巧还是技术全然是从某种角度来看的。或者说是从某种抽象层次来看的，假设这段代码在C++中实现，难道就叫技术，不是技巧了吗？当然不是。胖哥觉得技术依旧是建立在思想和方法基础上的，仅仅是看实现的抽象层次在什么级别。就像在本书中多个地方探讨的一些基础原理一样，我们探讨了它的思想，事实上它的实现也是基于某种技巧和手段的，仅仅是对程序封装后就变成了某种语法和API，因此胖哥觉得，一旦学会使用技巧思考问题，就学会了通过技巧去看待技术本身。我们应当通过这样的设计，学会一种变通和发散的思维。学会理解各种各样的场景。这样便能够积累很多真正的財富，这些財富不是通过某些工具的使用或測试就能够获得的。

ThreadLocal的这样的设计非常完美吗？
不是非常完美，它依旧有很多坑，在这里对它easy误导程序猿当成传參工具就不再多提了。以下我们来看看它的使用不当会导致什么技术上的问题。

（3）ThreadLocal的坑

通过上面的分析。我们能够认识到ThreadLocal事实上是与线程绑定的一个变量，如此就会出现一个问题：假设没有将ThreadLocal内的变量删除（remove）或替换，它的生命周期将会与线程共存。

因此，ThreadLocal的一个非常大的“坑”就是当使用不当时，导致使用者不知道它的作用域范围。
大家可能觉得线程结束后ThreadLocal应该就回收了。假设线程真的注销了确实是这种，可是事实有可能并不是如此。比如在线程池中对线程管理都是採用线程复用的方法（Web容器通常也会採用线程池）。在线程池中线程非常难结束甚至于永远不会结束。这将意味着线程持续的时间将不可预測，甚至与JVM的生命周期一致。

那么对应的ThreadLocal变量的生命周期也将不可预測。
或许系统中定义少量几个ThreadLocal变量也无所谓。由于每次set数据时是用ThreadLocal本身作为Key的，同样的Key肯定会替换原来的数据。原来的数据就能够被释放了，理论上不会导致什么问题。但世事无绝对，假设ThreadLocal中直接或间接包装了集合类或复杂对象，每次在同一个ThreadLocal中取出对象后，再对内容做操作，那么内部的集合类和复杂对象所占用的空间可能会開始膨胀。
抛开代码本身的问题。举一个极端的样例。假设不想定义太多的ThreadLocal变量，就用一个HashMap来存放，这貌似没什么问题。由于ThreadLocal在程序的不论什么一个地方都能够用得到，在某些设计不当的代码中非常难知道这个HashMap写入的源头，在代码中为了保险起见。一般会先检查这个HashMap是否存在，若不存在，则创建一个HashMap写进去。若存在，通常也不会替换掉。由于代码编写者一般会“害怕”由于这样的替换会丢掉一些来自“其它地方写入HashMap的数据”。从而导致很多不可预见的问题。
在这种情况下。HashMap第一次放入ThreadLocal中或许就一直不会被释放，而这个HashMap中可能開始存放很多Key-Value信息，假设业务上存放的Key值在不断变化（比如，将业务的ID作为Key），那么这个HashMap就開始不断变长，并且非常可能在每一个线程中都有一个这种HashMap，逐渐地形成了间接的内存泄漏。以前有非常多人吃过这个亏，并且吃亏的时候发现这种代码可能不是在自己的业务系统中。而是出如今某些二方包、三方包中（开源并不保证没有问题）。
要处理这样的问题非常复杂，只是首先要保证自己编写的代码是没问题的。要保证没问题不是说我们不去用ThreadLocal。甚至不去学习它。由于它肯定有其应用价值。在使用时要明确ThreadLocal最难以捉摸的是“不知道哪里是源头”（一般是代码设计不当导致的），仅仅有知道了源头才干控制结束的部分。或者说我们从设计的角度要让ThreadLocal的set、remove有始有终，通常在外部调用的代码中使用finally来remove数据，仅仅要我们细致思考和抽象是能够达到这个目的的。有些是二方包、三方包的问题，对于这些问题我们须要学会的是找到问题的根源后解决，关于二方包、三方包的执行跟踪，可參看第3.7.9节介绍的BTrace工具。

补充：在不论什么异步程序中（包含异步I/O、非堵塞I/O），ThreadLocal的參数传递是不靠谱的，由于线程将请求发送后。就不再等待远程返回结果继续向下运行了，真正的返回结果得到后，处理的线程可能是还有一个。

#####################################个人总结 ####################################

Thread.java源代码中:

ThreadLocal.ThreadLocalMap threadLocals = null;

即:每一个Thread对象都有一个ThreadLocal.ThreadLocalMap成员变量,ThreadLocal.ThreadLocalMap是一个ThreadLocal类的静态内部类(例如以下所看到的),所以Thread类能够进行引用.

static class ThreadLocalMap {

所以每一个线程都会有一个ThreadLocal.ThreadLocalMap对象的引用

当在ThreadLocal中进行设值的时候:

    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

首先获取当前线程的引用,然后获取当前线程的ThreadLocal.ThreadLocalMap对象(t.threadLocals变量就是ThreadLocal.ThreadLocalMap的变量),假设该对象为空就创建一个,例如以下所看到的:

    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

这个this变量就是ThreadLocal的引用,对于同一个ThreadLocal对象每一个线程都是同样的,可是每一个线程各自有一个ThreadLocal.ThreadLocalMap对象保存着各自ThreadLocal引用为key的值,所以互不影响,并且:假设你新建一个ThreadLocal的对象,这个对象还是保存在每一个线程同一个ThreadLocal.ThreadLocalMap对象之中,由于一个线程仅仅有一个ThreadLocal.ThreadLocalMap对象,这个对象是在第一个ThreadLocal第一次设值的时候进行创建,如上所述的createMap方法.

        ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }

总结:

深入研究java.lang.ThreadLocal类:http://blog.csdn.net/xiaohulunb/article/details/19603611

API说明:

ThreadLocal(),T get(),protected T initialValue(),void remove(),void set(T value)

典型实例:

1.Hiberante的Session 工具类HibernateUtil

2.通过不同的线程对象设置Bean属性，保证各个线程Bean对象的独立性。

ThreadLocal使用的一般步骤:

1、在多线程的类（如ThreadDemo类）中。创建一个ThreadLocal对象threadXxx，用来保存线程间须要隔离处理的对象xxx。
2、在ThreadDemo类中。创建一个获取要隔离訪问的数据的方法getXxx()，在方法中推断，若ThreadLocal对象为null时候，应该new()一个隔离訪问类型的对象，并强制转换为要应用的类型。
3、在ThreadDemo类的run()方法中。通过getXxx()方法获取要操作的数据。这样能够保证每一个线程相应一个数据对象，在不论什么时刻都操作的是这个对象。

与Synchonized的对照:

ThreadLocal和Synchonized都用于解决多线程并发訪问。可是ThreadLocal与synchronized有本质的差别。synchronized是利用锁的机制，使变量或代码块在某一时该仅仅能被一个线程訪问。而ThreadLocal为每个线程都提供了变量的副本，使得每个线程在某一时间訪问到的并非同一个对象，这样就隔离了多个线程对数据的数据共享。而Synchronized却正好相反，它用于在多个线程间通信时可以获得数据共享。
 
Synchronized用于线程间的数据共享，而ThreadLocal则用于线程间的数据隔离。

一句话理解ThreadLocal:向ThreadLocal里面存东西就是向它里面的Map存东西的，然后ThreadLocal把这个Map挂到当前的线程底下，这样Map就仅仅属于这个线程了。

使用ThreadLocal改进你的层次的划分(spring事务的实现):http://blog.csdn.net/zhouyong0/article/details/7761835

源代码剖析之ThreadLocal:http://wangxinchun.iteye.com/blog/1884228

Java中的ThreadLocal源代码解析（上）:http://maosidiaoxian.iteye.com/blog/1939142

ThreadLocal与synchronized:http://blog.csdn.net/yangairong1984/article/details/2294572

Java线程：深入ThreadLocal:http://lavasoft.blog.51cto.com/62575/258459(一个ThreadLocal的模拟实现)

Java多线程（六）、ThreadLocal类：http://blog.csdn.net/lonelyroamer/article/details/7998137