标签：
学习一个东西首先要知道为什么要引入它，就是我们能用它来干什么。所以我们先来看看ThreadLocal对我们到底有什么用，然后再来看看它的实现原理。
ThreadLocal如果单纯从名字上来看像是“本地线程"这么个意思，只能说这个名字起的确实不太好，很容易让人产生误解，ThreadLocalVariable（线程本地变量）应该是个更好的名字。我们先看一下官方对ThreadLocal的描述：
该类提供了线程局部 (thread-local) 变量。这些变量不同于它们的普通对应物，因为访问某个变量（通过其 get 或 set 方法）的每个线程都有自己的局部变量，它独立于变量的初始化副本。ThreadLocal 实例通常是类中的 private static 字段，它们希望将状态与某一个线程（例如，用户 ID 或事务 ID）相关联。
我们从中摘出要点：
1、每个线程都有自己的局部变量
每个线程都有一个独立于其他线程的上下文来保存这个变量，一个线程的本地变量对其他线程是不可见的（有前提，后面解释）
2、独立于变量的初始化副本
ThreadLocal可以给一个初始值，而每个线程都会获得这个初始化值的一个副本，这样才能保证不同的线程都有一份拷贝。
3、状态与某一个线程相关联
ThreadLocal 不是用于解决共享变量的问题的，不是为了协调线程同步而存在，而是为了方便每个线程处理自己的状态而引入的一个机制，理解这点对正确使用ThreadLocal至关重要。
我们先看一个简单的例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
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，各个线程处理自己的本地变量值，线程之间互不影响。
我们再来看一个例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
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的地方
|
1
2
3
4
5
6
7
|
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对象应该怎么办呢？那就是创建对象的副本而不是对象引用的副本：
|
1
2
3
4
5
6
|
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这两个最常用的方法开始分析：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
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方法:
|
1
2
3
4
|
//直接返回线程对象的threadLocals属性ThreadLocalMap getMap(Thread t) { return t.threadLocals; } |
setInitialValue方法：（看完后再回顾一下之前的那个例子）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
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方法
|
1
2
3
4
5
6
7
8
9
10
|
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方法，让我们来分析一下:
|
1
2
3
4
5
6
7
|
public void remove() { //获取当前线程的ThreadLocalMap对象 ThreadLocalMap m = getMap(Thread.currentThread()); //如果map不为空，则删除该本地变量的值 if (m != null) m.remove(this); } |
知其然
synchronized这类线程同步的机制可以解决多线程并发问题，在这种解决方案下，多个线程访问到的，都是同一份变量的内容。为了防止在多线程访问 的过程中，可能会出现的并发错误。不得不对多个线程的访问进行同步，这样也就意味着，多个线程必须先后对变量的值进行访问或者修改，这是一种以延长访问时 间来换取线程安全性的策略。
而ThreadLocal类为每一个线程都维护了自己独有的变量拷贝。每个线程都拥有了自己独立的一个变量，竞争条件被彻底消除了，那就没有任何必要对这 些线程进行同步，它们也能最大限度的由CPU调度，并发执行。并且由于每个线程在访问该变量时，读取和修改的，都是自己独有的那一份变量拷贝，变量被彻底 封闭在每个访问的线程中，并发错误出现的可能也完全消除了。对比前一种方案，这是一种以空间来换取线程安全性的策略。
来看一个运用ThreadLocal来实现数据库连接Connection对象线程隔离的例子。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;public class ConnectionManager { private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>() { @Override protected Connection initialValue() { Connection conn = null; try { conn = DriverManager.getConnection( "jdbc:mysql://localhost:3306/test", "username", "password"); } catch (SQLException e) { e.printStackTrace(); } return conn; } }; public static Connection getConnection() { return connectionHolder.get(); } public static void setConnection(Connection conn) { connectionHolder.set(conn); }} |
通过调用ConnectionManager.getConnection()方法，每个线程获取到的，都是和当前线程绑定的那个Connection对 象，第一次获取时，是通过initialValue()方法的返回值来设置值的。通过 ConnectionManager.setConnection(Connection conn)方法设置的Connection对象，也只会和当前线程绑定。这样就实现了Connection对象在多个线程中的完全隔离。在Spring容 器中管理多线程环境下的Connection对象时，采用的思路和以上代码非常相似。
知其所以然
那么到底ThreadLocal类是如何实现这种“为每个线程提供不同的变量拷贝”的呢？先来看一下ThreadLocal的set()方法的源码是如何实现的：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
/** * Sets the current thread‘s copy of this thread-local variable * to the specified value. Most subclasses will have no need to * override this method, relying solely on the {@link #initialValue} * method to set the values of thread-locals. * * @param value the value to be stored in the current thread‘s copy of * this thread-local. */ public void set(T value) { Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null) map.set(this, value); else createMap(t, value); } |
没有什么魔法，在这个方法内部我们看到，首先通过getMap(Thread t)方法获取一个和当前线程相关的ThreadLocalMap，然后将变量的值设置到这个ThreadLocalMap对象中，当然如果获取到的 ThreadLocalMap对象为空，就通过createMap方法创建。
线程隔离的秘密，就在于ThreadLocalMap这个类。ThreadLocalMap是ThreadLocal类的一个静态内部类，它实现了键值对 的设置和获取（对比Map对象来理解），每个线程中都有一个独立的ThreadLocalMap副本，它所存储的值，只能被当前线程读取和修改。 ThreadLocal类通过操作每一个线程特有的ThreadLocalMap副本，从而实现了变量访问在不同线程中的隔离。因为每个线程的变量都是自 己特有的，完全不会有并发错误。还有一点就是，ThreadLocalMap存储的键值对中的键是this对象指向的ThreadLocal对象，而值就 是你所设置的对象了。
为了加深理解，我们接着看上面代码中出现的getMap和createMap方法的实现：
|
1
2
3
|
ThreadLocalMap getMap(Thread t) { return t.threadLocals; } |
|
1
2
3
|
void createMap(Thread t, T firstValue) { t.threadLocals = new ThreadLocalMap(this, firstValue); } |
代码已经说的非常直白，就是获取和设置Thread内的一个叫threadLocals的变量，而这个变量的类型就是ThreadLocalMap，这样 进一步验证了上文中的观点：每个线程都有自己独立的ThreadLocalMap对象。打开java.lang.Thread类的源代码，我们能得到更直 观的证明：
|
1
2
3
|
/* ThreadLocal values pertaining to this thread. This map is maintained * by the ThreadLocal class. */ ThreadLocal.ThreadLocalMap threadLocals = null; |
那么接下来再看一下ThreadLocal类中的get()方法，代码是这么说的：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
/** * Returns the value in the current thread‘s copy of this * thread-local variable. If the variable has no value for the * current thread, it is first initialized to the value returned * by an invocation of the {@link #initialValue} method. * * @return the current thread‘s value of this thread-local */ public T get() { Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null) { ThreadLocalMap.Entry e = map.getEntry(this); if (e != null) return (T)e.value; } return setInitialValue(); } /** * Variant of set() to establish initialValue. Used instead * of set() in case user has overridden the set() method. * * @return the initial value */ private T setInitialValue() { T value = initialValue(); Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null) map.set(this, value); else createMap(t, value); return value; } |
这两个方法的代码告诉我们，在获取和当前线程绑定的值时，ThreadLocalMap对象是以this指向的ThreadLocal对象为键进行查找的，这当然和前面set()方法的代码是相呼应的。
进一步地，我们可以创建不同的ThreadLocal实例来实现多个变量在不同线程间的访问隔离，为什么可以这么做？因为不同的ThreadLocal对 象作为不同键，当然也可以在线程的ThreadLocalMap对象中设置不同的值了。通过ThreadLocal对象，在多线程中共享一个值和多个值的 区别，就像你在一个HashMap对象中存储一个键值对和多个键值对一样，仅此而已。
设置到这些线程中的隔离变量，会不会导致内存泄漏呢？ThreadLocalMap对象保存在Thread对象中，当某个线程终止后，存储在其中的线程隔 离的变量，也将作为Thread实例的垃圾被回收掉，所以完全不用担心内存泄漏的问题。在多个线程中隔离的变量，光荣的生，合理的死，真是圆满，不是么？
最后再提一句，ThreadLocal变量的这种隔离策略，也不是任何情况下都能使用的。如果多个线程并发访问的对象实例只允许，也只能创建那么一个，那就没有别的办法了，老老实实的使用同步机制来访问吧。
标签：
原文地址：http://www.cnblogs.com/timdes/p/4862481.html
