- 浏览: 7844 次
- 来自: ...
文章分类
最新评论
-
小琼樱:
http://blog.csdn.net/qjyong/art ...
正确理解ThreadLocal -
moshalanye:
青蛙支持下你! 呵呵!
个人理解: 这个 静态变量 Thre ...
正确理解ThreadLocal -
spiritfrog:
lz的这句话不对:首先,ThreadLocal 不是用来解决共 ...
正确理解ThreadLocal -
neptune:
那你就看看spring事务管理是如果实现的好了
正确理解ThreadLocal -
suntiance:
总结的不错。可以把各种框架和容器对ThreadLocal的应用 ...
正确理解ThreadLocal
首先,ThreadLocal 不是用来解决共享对象的多线程访问问题的,一般情况下,通过ThreadLocal.set() 到线程中的对象是该线程自己使用的对象,其他线程是不需要访问的,也访问不到的。各个线程中访问的是不同的对象。
另外,说ThreadLocal使得各线程能够保持各自独立的一个对象,并不是通过ThreadLocal.set()来实现的,而是通过每个线程中的new 对象 的操作来创建的对象,每个线程创建一个,不是什么对象的拷贝或副本。通过ThreadLocal.set()将这个新创建的对象的引用保存到各线程的自己的一个map中,每个线程都有这样一个map,执行ThreadLocal.get()时,各线程从自己的map中取出放进去的对象,因此取出来的是各自自己线程中的对象,ThreadLocal实例是作为map的key来使用的。
如果ThreadLocal.set()进去的东西本来就是多个线程共享的同一个对象,那么多个线程的ThreadLocal.get()取得的还是这个共享对象本身,还是有并发访问问题。
下面来看一个hibernate中典型的ThreadLocal的应用:
可以看到在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源码)
可以看到ThreadLocal类中的变量只有这3个int型:
而作为ThreadLocal实例的变量只有 threadLocalHashCode 这一个,nextHashCode 和HASH_INCREMENT 是ThreadLocal类的静态变量,实际上HASH_INCREMENT是一个常量,表示了连续分配的两个ThreadLocal实例的threadLocalHashCode值的增量,而nextHashCode 的表示了即将分配的下一个ThreadLocal实例的threadLocalHashCode 的值。
可以来看一下创建一个ThreadLocal实例即new ThreadLocal()时做了哪些操作,从上面看到构造函数ThreadLocal()里什么操作都没有,唯一的操作是这句:
那么nextHashCode()做了什么呢:
因此ThreadLocal实例的变量只有这个threadLocalHashCode,而且是final的,用来区分不同的ThreadLocal实例,ThreadLocal类主要是作为工具类来使用,那么ThreadLocal.set()进去的对象是放在哪儿的呢?
看一下上面的set()方法,两句合并一下成为
这个ThreadLocalMap 类是ThreadLocal中定义的内部类,但是它的实例却用在Thread类中:
再看这句:
也就是将该ThreadLocal实例作为key,要保持的对象作为值,设置到当前线程的ThreadLocalMap 中,get()方法同样大家看了代码也就明白了,ThreadLocalMap 类的代码太多了,我就不帖了,自己去看源码吧。
写了这么多,也不知讲明白了没有,有什么不当的地方还请大家指出来。
每个ThreadLocal当然只能放一个对象。要是需要放其他的对象,就再new 一个新的ThreadLocal出来,这个新的ThreadLocal作为key,需要放的对象作为value,放在ThreadLocalMap中。。。。
不是快一点两点的,jdk 1.3之前的实现是非常之慢的!
其实在jdk1.4之前的ThreadLocal的实现就是类似第一种情况的实现,jdk1.4就改成后面那种实现。
至于好处,除了可以自动释放外,还有一个很重要的好处:速度快了很多。
不是啊,我看了一下jdk1.3的源码,这一点上和1.4、1.5是一样的,map都是放在每个线程中的,以threadLocal为key,所不同的是,在1.3中这个map是个普通的HashMap,而1.4和1.5中是个ThreadLocalMap类,一个明显的特征是其中的Entry用到了弱引用WeakReference 类,但我感觉这个WeakReference的用法在这里并不能起到应有的作用。
另外想到一个把map放到各自线程中带来的好处是 因为各线程访问的map是各自不同的map,所以不需要同步,速度会快些;而如果把所有线程要用的对象都放到一个静态map中的话 多线程并发访问需要进行同步。
其实在jdk1.4之前的ThreadLocal的实现就是类似第一种情况的实现,jdk1.4就改成后面那种实现。
至于好处,除了可以自动释放外,还有一个很重要的好处:速度快了很多。
另外,说ThreadLocal使得各线程能够保持各自独立的一个对象,并不是通过ThreadLocal.set()来实现的,而是通过每个线程中的new 对象 的操作来创建的对象,每个线程创建一个,不是什么对象的拷贝或副本。通过ThreadLocal.set()将这个新创建的对象的引用保存到各线程的自己的一个map中,每个线程都有这样一个map,执行ThreadLocal.get()时,各线程从自己的map中取出放进去的对象,因此取出来的是各自自己线程中的对象,ThreadLocal实例是作为map的key来使用的。
如果ThreadLocal.set()进去的东西本来就是多个线程共享的同一个对象,那么多个线程的ThreadLocal.get()取得的还是这个共享对象本身,还是有并发访问问题。
下面来看一个hibernate中典型的ThreadLocal的应用:
private static final ThreadLocal threadSession = new ThreadLocal(); public static Session getSession() throws InfrastructureException { Session s = (Session) threadSession.get(); try { if (s == null) { s = getSessionFactory().openSession(); threadSession.set(s); } } catch (HibernateException ex) { throw new InfrastructureException(ex); } 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源码)
public class ThreadLocal<T> { /** * ThreadLocals rely on per-thread hash maps attached to each thread * (Thread.threadLocals and inheritableThreadLocals). The ThreadLocal * objects act as keys, searched via threadLocalHashCode. This is a * custom hash code (useful only within ThreadLocalMaps) that eliminates * collisions in the common case where consecutively constructed * ThreadLocals are used by the same threads, while remaining well-behaved * in less common cases. */ private final int threadLocalHashCode = nextHashCode(); /** * The next hash code to be given out. Accessed only by like-named method. */ private static int nextHashCode = 0; /** * The difference between successively generated hash codes - turns * implicit sequential thread-local IDs into near-optimally spread * multiplicative hash values for power-of-two-sized tables. */ private static final int HASH_INCREMENT = 0x61c88647; /** * Compute the next hash code. The static synchronization used here * should not be a performance bottleneck. When ThreadLocals are * generated in different threads at a fast enough rate to regularly * contend on this lock, memory contention is by far a more serious * problem than lock contention. */ private static synchronized int nextHashCode() { int h = nextHashCode; nextHashCode = h + HASH_INCREMENT; return h; } /** * Creates a thread local variable. */ public ThreadLocal() { } /** * Returns the value in the current thread's copy of this thread-local * variable. Creates and initializes the copy if this is the first time * the thread has called this 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) return (T)map.get(this); // Maps are constructed lazily. if the map for this thread // doesn't exist, create it, with this ThreadLocal and its // initial value as its only entry. T value = initialValue(); createMap(t, value); return value; } /** * Sets the current thread's copy of this thread-local variable * to the specified value. Many applications will have no need for * this functionality, relying solely on the {@link #initialValue} * method to set the values of thread-locals. * * @param value the value to be stored in the current threads' 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); } /** * Get the map associated with a ThreadLocal. Overridden in * InheritableThreadLocal. * * @param t the current thread * @return the map */ ThreadLocalMap getMap(Thread t) { return t.threadLocals; } /** * Create the map associated with a ThreadLocal. Overridden in * InheritableThreadLocal. * * @param t the current thread * @param firstValue value for the initial entry of the map * @param map the map to store. */ void createMap(Thread t, T firstValue) { t.threadLocals = new ThreadLocalMap(this, firstValue); } ....... /** * ThreadLocalMap is a customized hash map suitable only for * maintaining thread local values. No operations are exported * outside of the ThreadLocal class. The class is package private to * allow declaration of fields in class Thread. To help deal with * very large and long-lived usages, the hash table entries use * WeakReferences for keys. However, since reference queues are not * used, stale entries are guaranteed to be removed only when * the table starts running out of space. */ static class ThreadLocalMap { ........ } }
可以看到ThreadLocal类中的变量只有这3个int型:
private final int threadLocalHashCode = nextHashCode(); private static int nextHashCode = 0; private static final int HASH_INCREMENT = 0x61c88647;
而作为ThreadLocal实例的变量只有 threadLocalHashCode 这一个,nextHashCode 和HASH_INCREMENT 是ThreadLocal类的静态变量,实际上HASH_INCREMENT是一个常量,表示了连续分配的两个ThreadLocal实例的threadLocalHashCode值的增量,而nextHashCode 的表示了即将分配的下一个ThreadLocal实例的threadLocalHashCode 的值。
可以来看一下创建一个ThreadLocal实例即new ThreadLocal()时做了哪些操作,从上面看到构造函数ThreadLocal()里什么操作都没有,唯一的操作是这句:
private final int threadLocalHashCode = nextHashCode();
那么nextHashCode()做了什么呢:
private static synchronized int nextHashCode() { int h = nextHashCode; nextHashCode = h + HASH_INCREMENT; return h; }就是将ThreadLocal类的下一个hashCode值即nextHashCode的值赋给实例的threadLocalHashCode,然后nextHashCode的值增加HASH_INCREMENT这个值。
因此ThreadLocal实例的变量只有这个threadLocalHashCode,而且是final的,用来区分不同的ThreadLocal实例,ThreadLocal类主要是作为工具类来使用,那么ThreadLocal.set()进去的对象是放在哪儿的呢?
看一下上面的set()方法,两句合并一下成为
ThreadLocalMap map = Thread.currentThread().threadLocals;
这个ThreadLocalMap 类是ThreadLocal中定义的内部类,但是它的实例却用在Thread类中:
public class Thread implements Runnable { ...... /* ThreadLocal values pertaining to this thread. This map is maintained * by the ThreadLocal class. */ ThreadLocal.ThreadLocalMap threadLocals = null; ...... }
再看这句:
if (map != null) map.set(this, value);
也就是将该ThreadLocal实例作为key,要保持的对象作为值,设置到当前线程的ThreadLocalMap 中,get()方法同样大家看了代码也就明白了,ThreadLocalMap 类的代码太多了,我就不帖了,自己去看源码吧。
写了这么多,也不知讲明白了没有,有什么不当的地方还请大家指出来。
评论
19 楼
小琼樱
2012-09-05
http://blog.csdn.net/qjyong/article/details/2158097 觉得这个写得更加好理解写
当然楼主写得也很有帮助
当然楼主写得也很有帮助
18 楼
moshalanye
2008-06-06
青蛙支持下你! 呵呵!
个人理解: 这个 静态变量 ThreadLocal.ThreadLocalMap threadLocals 从实现上放在哪里都一样可以,只是规范和语义上来说放在Thread 里面更合理,
Thread t = Thread.currentThread(); 用来获得存放map的对象也更快捷(nitive方法麻)
既然threadLocal 是key 那么不同线程使用同一个threadLocal对象 ,那么他们存什么进去肯定都会覆盖原来的其他线程存进去
如果不同线程 使用不同的 threadLocal对象 存的value 是同一个对象 ,那么他们就在共享一个value ,这个时候 value 就是一个多线程的 resource 这个时候就是要考虑下并发安全了 :)
不过好像把resource作为共享数据buffer来操作不大合理,一般这样的buffer都是拥有自己的业务需求了,不够common,应该自己另外定义一个共享数据源给多个线程作为私有数据或是(共享数据源是静态的可供线程访问), 而不是通过local放到map里去
一般看到的使用local的用法,都是存放一些数据库资源信息或是session(信息量少)
to : csrcom 有点不明白为什么要这么做,set的value 是obejct ,自己定义的类 和jdk 的集合类 不都是object的麻 ,只是进去出来转一下就好
现在我有个新问题: 希望有人解答
我看到在ThreadLocal类实现中 只看到remove()方法,那么我是否可以这么理解?在拥有 ThreadLocal对象(有可能是静态对象,也可能不是静态对象) 的线程结束时一定的记得判断 从local 塞进去的value 是否还需要,如果不需要了,然而没有调用remove()方法,多出现几次 Thread 中静态的 localMap 会只进不出越来越大,也就是无意思的内存未回收
这样的情况是否都必须自己来做 remove() 回收, 还是有其他的机制已经做了这件事?
希望大家别吝啬手上的石头,砸到我醒为止! :)
个人理解: 这个 静态变量 ThreadLocal.ThreadLocalMap threadLocals 从实现上放在哪里都一样可以,只是规范和语义上来说放在Thread 里面更合理,
Thread t = Thread.currentThread(); 用来获得存放map的对象也更快捷(nitive方法麻)
既然threadLocal 是key 那么不同线程使用同一个threadLocal对象 ,那么他们存什么进去肯定都会覆盖原来的其他线程存进去
如果不同线程 使用不同的 threadLocal对象 存的value 是同一个对象 ,那么他们就在共享一个value ,这个时候 value 就是一个多线程的 resource 这个时候就是要考虑下并发安全了 :)
不过好像把resource作为共享数据buffer来操作不大合理,一般这样的buffer都是拥有自己的业务需求了,不够common,应该自己另外定义一个共享数据源给多个线程作为私有数据或是(共享数据源是静态的可供线程访问), 而不是通过local放到map里去
一般看到的使用local的用法,都是存放一些数据库资源信息或是session(信息量少)
to : csrcom 有点不明白为什么要这么做,set的value 是obejct ,自己定义的类 和jdk 的集合类 不都是object的麻 ,只是进去出来转一下就好
现在我有个新问题: 希望有人解答
我看到在ThreadLocal类实现中 只看到remove()方法,那么我是否可以这么理解?在拥有 ThreadLocal对象(有可能是静态对象,也可能不是静态对象) 的线程结束时一定的记得判断 从local 塞进去的value 是否还需要,如果不需要了,然而没有调用remove()方法,多出现几次 Thread 中静态的 localMap 会只进不出越来越大,也就是无意思的内存未回收
这样的情况是否都必须自己来做 remove() 回收, 还是有其他的机制已经做了这件事?
希望大家别吝啬手上的石头,砸到我醒为止! :)
17 楼
spiritfrog
2008-06-06
lz的这句话不对:
首先,ThreadLocal 不是用来解决共享对象的多线程访问问题的,一般情况下,通过ThreadLocal.set() 到线程中的对象是该线程自己使用的对象,其他线程是不需要访问的,也访问不到的。各个线程中访问的是不同的对象。
其他线程能否访问,还要看你的get和set怎么写了, 如果两个线程都存入同一个对象引用,那就会有线程共享问题。
首先,ThreadLocal 不是用来解决共享对象的多线程访问问题的,一般情况下,通过ThreadLocal.set() 到线程中的对象是该线程自己使用的对象,其他线程是不需要访问的,也访问不到的。各个线程中访问的是不同的对象。
其他线程能否访问,还要看你的get和set怎么写了, 如果两个线程都存入同一个对象引用,那就会有线程共享问题。
16 楼
neptune
2008-06-05
那你就看看spring事务管理是如果实现的好了
15 楼
suntiance
2008-06-05
总结的不错。可以把各种框架和容器对ThreadLocal的应用拿来一起分析一下,看看究竟有什么神奇的地方。
14 楼
wuyingsong
2008-06-05
jieyuan_cg 写道
LZ的这篇对ThreadLocal的解释真到位。。。多谢!
坛子里面有几篇对ThreadLocal的解释好像都有些误解。。。看得晕晕乎乎。
坛子里面有几篇对ThreadLocal的解释好像都有些误解。。。看得晕晕乎乎。
13 楼
tenderghost
2008-06-03
学习了,有机会用一下。
12 楼
class_syh
2008-05-26
受教了,只是用过,没有分析这么透彻。
11 楼
racnow
2008-05-26
受益,真正理解ThreadLocal了,收藏
10 楼
csrcom
2008-05-22
其实可以在thread local存放更丰富的对象比如Map,那么就不用实例化那么thread local了
package com.meidusa.amoeba.util; import java.util.HashMap; import java.util.Map; import org.apache.log4j.Logger; /** * ThreadLocal Context * @author <a href=mailto:piratebase@sina.com>Struct chen</a> * @version $Id: ThreadLocalContext.java 3597 2006-11-23 08:11:58Z struct $ */ public class ThreadLocalMap{ private static Logger logger = Logger.getLogger(ThreadLocalMap.class); protected final static ThreadLocal<Map<String,Object>> threadContext = new MapThreadLocal(); private ThreadLocalMap(){}; public static void put(String key,Object value){ getContextMap().put(key,value); } public static Object remove(String key){ return getContextMap().remove(key); } public static Object get(String key){ return getContextMap().get(key); } private static class MapThreadLocal extends ThreadLocal<Map<String,Object>> { protected Map<String,Object> initialValue() { return new HashMap<String,Object>() { private static final long serialVersionUID = 3637958959138295593L; public Object put(String key, Object value) { if (logger.isDebugEnabled()) { if (containsKey(key)) { logger.debug("Overwritten attribute to thread context: " + key + " = " + value); } else { logger.debug("Added attribute to thread context: " + key + " = " + value); } } return super.put(key, value); } }; } } /** * 取得thread context Map的实例。 * * @return thread context Map的实例 */ protected static Map<String,Object> getContextMap() { return (Map<String,Object>) threadContext.get(); } /** * 清理线程所有被hold住的对象。以便重用! */ public static void reset(){ getContextMap().clear(); } }
9 楼
elice
2008-05-22
主要是提供了保持对象的方法和避免参数传递的方便的对象访问方式
8 楼
dafei2599
2008-05-13
LZ简直是神贴,写的真是明了.
7 楼
jieyuan_cg
2008-04-02
LZ的这篇对ThreadLocal的解释真到位。。。多谢!
坛子里面有几篇对ThreadLocal的解释好像都有些误解。。。看得晕晕乎乎。
坛子里面有几篇对ThreadLocal的解释好像都有些误解。。。看得晕晕乎乎。
6 楼
jieyuan_cg
2008-04-02
SINCE1978 写道
我想知道如果多次new ThreadLocal并且调用其set方法的话、是否就和普通hashmap一样后set进去的会覆盖先set进去的?这样的话ThreadLocal只能植入一个资源喽?这肯定不对,否则还用ThreadLocalMap这个自定义哈希表干什么,那么如何区分一个线程当中不同方法或不同类set进去的资源?并正确set和get??
每个ThreadLocal当然只能放一个对象。要是需要放其他的对象,就再new 一个新的ThreadLocal出来,这个新的ThreadLocal作为key,需要放的对象作为value,放在ThreadLocalMap中。。。。
5 楼
SINCE1978
2007-11-16
我想知道如果多次new ThreadLocal并且调用其set方法的话、是否就和普通hashmap一样后set进去的会覆盖先set进去的?这样的话ThreadLocal只能植入一个资源喽?这肯定不对,否则还用ThreadLocalMap这个自定义哈希表干什么,那么如何区分一个线程当中不同方法或不同类set进去的资源?并正确set和get??
4 楼
hax
2007-08-21
lujh99 写道
另外想到一个把map放到各自线程中带来的好处是 因为各线程访问的map是各自不同的map,所以不需要同步,速度会快些;而如果把所有线程要用的对象都放到一个静态map中的话 多线程并发访问需要进行同步。
不是快一点两点的,jdk 1.3之前的实现是非常之慢的!
3 楼
liangguanhui
2007-08-21
可能是我搞错了,是1.3的时候改写的
2 楼
lujh99
2007-07-23
liangguanhui 写道
引用
或者可以自己定义一个静态的map,将当前thread作为key,创建的session作为值,put到map中,应该也行,这也是一般人的想法,但事实上,ThreadLocal的实现刚好相反,它是在每个线程中有一个map,而将ThreadLocal实例作为key,这样每个map中的项数很少,而且当线程销毁时相应的东西也一起销毁了,不知道除了这些还有什么其他的好处。
其实在jdk1.4之前的ThreadLocal的实现就是类似第一种情况的实现,jdk1.4就改成后面那种实现。
至于好处,除了可以自动释放外,还有一个很重要的好处:速度快了很多。
不是啊,我看了一下jdk1.3的源码,这一点上和1.4、1.5是一样的,map都是放在每个线程中的,以threadLocal为key,所不同的是,在1.3中这个map是个普通的HashMap,而1.4和1.5中是个ThreadLocalMap类,一个明显的特征是其中的Entry用到了弱引用WeakReference 类,但我感觉这个WeakReference的用法在这里并不能起到应有的作用。
另外想到一个把map放到各自线程中带来的好处是 因为各线程访问的map是各自不同的map,所以不需要同步,速度会快些;而如果把所有线程要用的对象都放到一个静态map中的话 多线程并发访问需要进行同步。
1 楼
liangguanhui
2007-07-23
引用
或者可以自己定义一个静态的map,将当前thread作为key,创建的session作为值,put到map中,应该也行,这也是一般人的想法,但事实上,ThreadLocal的实现刚好相反,它是在每个线程中有一个map,而将ThreadLocal实例作为key,这样每个map中的项数很少,而且当线程销毁时相应的东西也一起销毁了,不知道除了这些还有什么其他的好处。
其实在jdk1.4之前的ThreadLocal的实现就是类似第一种情况的实现,jdk1.4就改成后面那种实现。
至于好处,除了可以自动释放外,还有一个很重要的好处:速度快了很多。
相关推荐
正确理解ThreadLocal.pdf
理解ThreadLocal 理解ThreadLocal 理解ThreadLocal 理解ThreadLocal
ThreadLocal应用示例及理解,这个写了相关的示例,可以参考一下。
ThreadLocal为解决多线程程序的并发问题提供了一种新的思路。使用这个工具类可以很简洁地编写出优美的多线程程序,ThreadLocal并不是一个Thread,而是Thread的局部变量
并且由于每个线程在访问该变量时,读取和修改的,都是独有的那份变量拷贝,变量被彻底封闭在每个访问的线程中,并发错误出现的可能也完全消除了。} catch (SQL
ThreadLocal入门教程。 讲解了线程安全和ThreadLocal的使用的基本知识。
ThreadLocal
ThreadLocal深度理解
主要介绍了深入理解ThreadLocal工作原理及使用示例,涉及ThreadLocal<T> 简介和使用示例及ThreadLocal的原理等相关内容,具有一定参考价值,需要的朋友可以了解下。
Java中ThreadLocal工具类(解决多线程程序中并发问题的一种新思路,主要为参数的拷贝问题),感兴趣的话可以查看博文,博文地址:http://blog.csdn.net/otengyue/article/details/38459327
ThreadLocal的简单理解.doc
学习ThreadLocal,了解其中的原理,以及学习其中的优点!避免坑点!!
DbUTils中用ThreadLocal类
主要介绍ThreadLocal的原理,实例分析以及注意事项
java 简单的ThreadLocal示例
ThreadLocal的几种误区ThreadLocal的几种误区ThreadLocal的几种误区
Synchronized与ThreadLocal