标签:
学习一个东西首先要知道为什么要引入它,就是我们能用它来干什么。所以我们先来看看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