正确理解ThreadLocal_Android, Python及开发编程讨论区_Weblogic技术|Tuxedo技术|中间件技术|Oracle论坛|JAVA论坛|Linux/Unix技术|hadoop论坛_联动北方技术论坛  
网站首页 | 关于我们 | 服务中心 | 经验交流 | 公司荣誉 | 成功案例 | 合作伙伴 | 联系我们 |
联动北方-国内领先的云技术服务提供商
»  游客             当前位置:  论坛首页 »  自由讨论区 »  Android, Python及开发编程讨论区 »
总帖数
5
每页帖数
101/1页1
返回列表
0
发起投票  发起投票 发新帖子
查看: 2497 | 回复: 4   主题: 正确理解ThreadLocal        下一篇 
吹牛打豆豆
注册用户
等级:中尉
经验:418
发帖:12
精华:0
注册:2015-3-30
状态:离线
发送短消息息给吹牛打豆豆 加好友    发送短消息息给吹牛打豆豆 发消息
发表于: IP:您无权察看 2015-5-21 11:46:04 | [全部帖] [楼主帖] 楼主

ThreadLocal是什么

早在JDK 1.2的版本中就提供java.lang.ThreadLocal,ThreadLocal为解决多线程程序的并发问题提供了一种新的思路。使用这个工具类可以很简洁地编写出优美的多线程程序。

ThreadLocal很容易让人望文生义,想当然地认为是一个“本地线程”。其实,ThreadLocal并不是一个Thread,而是Thread的局部变量,也许把它命名为ThreadLocalVariable更容易让人理解一些。

当使用ThreadLocal维护变量时,ThreadLocal为每个使用该变量的线程提供独立的变量副本,所以每一个线程都可以独立地改变自己的副本,而不会影响其它线程所对应的副本。

从线程的角度看,目标变量就象是线程的本地变量,这也是类名中“Local”所要表达的意思。

线程局部变量并不是Java的新发明,很多语言(如IBM IBM XL FORTRAN)在语法层面就提供线程局部变量。在Java中没有提供在语言级支持,而是变相地通过ThreadLocal的类提供支持。

所以,在Java中编写线程局部变量的代码相对来说要笨拙一些,因此造成线程局部变量没有在Java开发者中得到很好的普及。

首先,ThreadLocal 不是用来解决共享对象的多线程访问问题的,一般情况下,通过ThreadLocal.set() 到线程中的对象是该线程自己使用的对象,其他线程是不需要访问的,也访问不到的。各个线程中访问的是不同的对象。 

另外,说ThreadLocal使得各线程能够保持各自独立的一个对象,并不是通过ThreadLocal.set()来实现的,而是通过每个线程中的new 对象 的操作来创建的对象,每个线程创建一个,不是什么对象的拷贝或副本。通过ThreadLocal.set()将这个新创建的对象的引用保存到各线程的自己的一个map中,每个线程都有这样一个map,执行ThreadLocal.get()时,各线程从自己的map中取出放进去的对象,因此取出来的是各自自己线程中的对象,ThreadLocal实例是作为map的key来使用的。 

如果ThreadLocal.set()进去的东西本来就是多个线程共享的同一个对象,那么多个线程的ThreadLocal.get()取得的还是这个共享对象本身,还是有并发访问问题。 

下面来看一个hibernate中典型的ThreadLocal的应用: 

Java代码 

  1. privatestaticfinal ThreadLocal threadSession = new ThreadLocal(); 
  2. publicstatic Session getSession() throws InfrastructureException { 
  3.        Session s = (Session) threadSession.get(); 
  4.       try { 
  5.             if (s == null) { 
  6.                    s = getSessionFactory().openSession(); 
  7.                    threadSession.set(s); 
  8.              } 
  9.        } catch (HibernateException ex) { 
  10.             thrownew InfrastructureException(ex); 
  11.        } 
  12.       return s; 


可以看到在getSession()方法中,首先判断当前线程中有没有放进去session,如果还没有,那么通过sessionFactory().openSession()来创建一个session,再将session set到线程中,实际是放到当前线程的ThreadLocalMap这个map中,这时,对于这个session的唯一引用就是当前线程中的那个ThreadLocalMap(下面会讲到),而threadSession作为这个值的key,要取得这个session可以通过threadSession.get()来得到,里面执行的操作实际是先取得当前线程中的ThreadLocalMap,然后将threadSession作为key将对应的值取出。这个session相当于线程的私有变量,而不是public的。 
显然,其他线程中是取不到这个session的,他们也只能取到自己的ThreadLocalMap中的东西。要是session是多个线程共享使用的,那还不乱套了。 
试想如果不用ThreadLocal怎么来实现呢?可能就要在action中创建session,然后把session一个个传到service和dao中,这可够麻烦的。或者可以自己定义一个静态的map,将当前thread作为key,创建的session作为值,put到map中,应该也行,这也是一般人的想法,但事实上,ThreadLocal的实现刚好相反,它是在每个线程中有一个map,而将ThreadLocal实例作为key,这样每个map中的项数很少,而且当线程销毁时相应的东西也一起销毁了,不知道除了这些还有什么其他的好处。 

总之,ThreadLocal不是用来解决对象共享访问问题的,而主要是提供了保持对象的方法和避免参数传递的方便的对象访问方式。归纳了两点: 
1。每个线程中都有一个自己的ThreadLocalMap类对象,可以将线程自己的对象保持到其中,各管各的,线程可以正确的访问到自己的对象。 
2。将一个共用的ThreadLocal静态实例作为key,将不同对象的引用保存到不同线程的ThreadLocalMap中,然后在线程执行的各处通过这个静态ThreadLocal实例的get()方法取得自己线程保存的那个对象,避免了将这个对象作为参数传递的麻烦。



当然如果要把本来线程共享的对象通过ThreadLocal.set()放到线程中也可以,可以实现避免参数传递的访问方式,但是要注意get()到的是那同一个共享对象,并发访问问题要靠其他手段来解决。但一般来说线程共享的对象通过设置为某类的静态变量就可以实现方便的访问了,似乎没必要放到线程中。 

ThreadLocal的应用场合,我觉得最适合的是按线程多实例(每个线程对应一个实例)的对象的访问,并且这个对象很多地方都要用到。



下面来看看ThreadLocal的实现原理(jdk1.5源码) 

Java代码 

  1. publicclass ThreadLocal<T> { 
  2.       
  3.       privatefinalint threadLocalHashCode = nextHashCode(); 
  4.       
  5.       
  6.       privatestaticint nextHashCode = 0; 
  7.       
  8.       
  9.       privatestaticfinalint HASH_INCREMENT = 0x61c88647; 
  10.       
  11.       
  12.       privatestaticsynchronizedint nextHashCode() { 
  13.             int h = nextHashCode; 
  14.              nextHashCode = h + HASH_INCREMENT; 
  15.             return h; 
  16.        } 
  17.       
  18.       
  19.       public ThreadLocal() { 
  20.        } 
  21.       
  22.       
  23.       public T get() { 
  24.              Thread t = Thread.currentThread(); 
  25.              ThreadLocalMap map = getMap(t); 
  26.             if (map != null) 
  27.             return (T)map.get(this); 
  28.             
  29.             // Maps are constructed lazily. if the map for this thread
  30.             // doesn't exist, create it, with this ThreadLocal and its
  31.             // initial value as its only entry.
  32.              T value = initialValue(); 
  33.              createMap(t, value); 
  34.             return value; 
  35.        } 
  36.       
  37.       
  38.       publicvoid set(T value) { 
  39.              Thread t = Thread.currentThread(); 
  40.              ThreadLocalMap map = getMap(t); 
  41.             if (map != null) 
  42.              map.set(this, value); 
  43.             else
  44.              createMap(t, value); 
  45.        } 
  46.       
  47.       
  48.        ThreadLocalMap getMap(Thread t) { 
  49.             return t.threadLocals; 
  50.        } 
  51.       
  52.       
  53.       void createMap(Thread t, T firstValue) { 
  54.              t.threadLocals = new ThreadLocalMap(this, firstValue); 
  55.        } 
  56.       
  57.        ....... 
  58.       
  59.       
  60.       staticclass ThreadLocalMap { 
  61.             
  62.              ........ 
  63.             
  64.        } 
  65.       


可以看到ThreadLocal类中的变量只有这3个int型: 

Java代码 

  1. privatefinalint threadLocalHashCode = nextHashCode();  
  2. privatestaticint nextHashCode = 0;  
  3. privatestaticfinalint HASH_INCREMENT = 0x61c88647;  


而作为ThreadLocal实例的变量只有 threadLocalHashCode 这一个,nextHashCode 和HASH_INCREMENT 是ThreadLocal类的静态变量,实际上HASH_INCREMENT是一个常量,表示了连续分配的两个ThreadLocal实例的threadLocalHashCode值的增量,而nextHashCode 的表示了即将分配的下一个ThreadLocal实例的threadLocalHashCode 的值。 

可以来看一下创建一个ThreadLocal实例即new ThreadLocal()时做了哪些操作,从上面看到构造函数ThreadLocal()里什么操作都没有,唯一的操作是这句: 

Java代码 

  1. privatefinalint threadLocalHashCode = nextHashCode();  


那么nextHashCode()做了什么呢: 

Java代码 

  1. privatestaticsynchronizedint nextHashCode() { 
  2.       int h = nextHashCode; 
  3.        nextHashCode = h + HASH_INCREMENT; 
  4.       return h; 


就是将ThreadLocal类的下一个hashCode值即nextHashCode的值赋给实例的threadLocalHashCode,然后nextHashCode的值增加HASH_INCREMENT这个值。 

因此ThreadLocal实例的变量只有这个threadLocalHashCode,而且是final的,用来区分不同的ThreadLocal实例,ThreadLocal类主要是作为工具类来使用,那么ThreadLocal.set()进去的对象是放在哪儿的呢? 

看一下上面的set()方法,两句合并一下成为 

Java代码 

  1. ThreadLocalMap map = Thread.currentThread().threadLocals;  


这个ThreadLocalMap 类是ThreadLocal中定义的内部类,但是它的实例却用在Thread类中: 

Java代码 

  1. publicclass Thread implements Runnable { 
  2.        ...... 
  3.       
  4.       
  5.        ThreadLocal.ThreadLocalMap threadLocals = null; 
  6.        ...... 


再看这句: 

Java代码 

  1. if (map != null)  
  2.     map.set(this, value);  


也就是将该ThreadLocal实例作为key,要保持的对象作为值,设置到当前线程的ThreadLocalMap 中,get()方法同样大家看了代码也就明白了,ThreadLocalMap 同理看源码。




赞(0)    操作        顶端 
hei_nihao
注册用户
等级:少校
经验:1279
发帖:19
精华:0
注册:2015-4-17
状态:离线
发送短消息息给hei_nihao 加好友    发送短消息息给hei_nihao 发消息
发表于: IP:您无权察看 2015-5-28 17:53:58 | [全部帖] [楼主帖] 2  楼

我好想在哪里见过



赞(0)    操作        顶端 
我也是醉了
注册用户
等级:中士
经验:241
发帖:1
精华:0
注册:2015-5-13
状态:离线
发送短消息息给我也是醉了 加好友    发送短消息息给我也是醉了 发消息
发表于: IP:您无权察看 2015-5-29 8:51:44 | [全部帖] [楼主帖] 3  楼

我好想在哪里见过
我也有点



赞(0)    操作        顶端 
llei.zhang
注册用户
等级:中尉
经验:492
发帖:18
精华:0
注册:1970-1-1
状态:离线
发送短消息息给llei.zhang 加好友    发送短消息息给llei.zhang 发消息
发表于: IP:您无权察看 2015-6-8 9:52:23 | [全部帖] [楼主帖] 4  楼

前两天学习Struts中用到了threadlocal,学习下



赞(0)    操作        顶端 
superstar
注册用户
等级:上尉
经验:525
发帖:2
精华:0
注册:2015-6-3
状态:离线
发送短消息息给superstar 加好友    发送短消息息给superstar 发消息
发表于: IP:您无权察看 2015-6-8 11:17:19 | [全部帖] [楼主帖] 5  楼

表示有做过ThreadLocal的面试题



赞(0)    操作        顶端 
总帖数
5
每页帖数
101/1页1
返回列表
发新帖子
请输入验证码: 点击刷新验证码
您需要登录后才可以回帖 登录 | 注册
技术讨论