Threadlocal.docx
- 文档编号:17221978
- 上传时间:2023-07-23
- 格式:DOCX
- 页数:17
- 大小:53.55KB
Threadlocal.docx
《Threadlocal.docx》由会员分享,可在线阅读,更多相关《Threadlocal.docx(17页珍藏版)》请在冰点文库上搜索。
Threadlocal
首先,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.private static final ThreadLocal threadSession = new ThreadLocal();
2.
3.public static Session getSession() throws InfrastructureException {
4. Session s = (Session) threadSession.get();
5. try {
6. if (s == null) {
7. s = getSessionFactory().openSession();
8. threadSession.set(s);
9. }
10. } catch (HibernateException ex) {
11. throw new InfrastructureException(ex);
12. }
13. return s;
14.}
可以看到在getSession()方法中,首先判断当前线程中有没有放进去session,如果还没有,那么通过sessionFactory().openSession()来创建一个session,再将sessionset到线程中,实际是放到当前线程的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.public class ThreadLocal
2. /**
3. * ThreadLocals rely on per-thread hash maps attached to each thread
4. * (Thread.threadLocals and inheritableThreadLocals). The ThreadLocal
5. * objects act as keys, searched via threadLocalHashCode. This is a
6. * custom hash code (useful only within ThreadLocalMaps) that eliminates
7. * collisions in the common case where consecutively constructed
8. * ThreadLocals are used by the same threads, while remaining well-behaved
9. * in less common cases.
10. */
11. private final int threadLocalHashCode = nextHashCode();
12.
13. /**
14. * The next hash code to be given out. Accessed only by like-named method.
15. */
16. private static int nextHashCode = 0;
17.
18. /**
19. * The difference between successively generated hash codes - turns
20. * implicit sequential thread-local IDs into near-optimally spread
21. * multiplicative hash values for power-of-two-sized tables.
22. */
23. private static final int HASH_INCREMENT = 0x61c88647;
24.
25. /**
26. * Compute the next hash code. The static synchronization used here
27. * should not be a performance bottleneck. When ThreadLocals are
28. * generated in different threads at a fast enough rate to regularly
29. * contend on this lock, memory contention is by far a more serious
30. * problem than lock contention.
31. */
32. private static synchronized int nextHashCode() {
33. int h = nextHashCode;
34. nextHashCode = h + HASH_INCREMENT;
35. return h;
36. }
37.
38. /**
39. * Creates a thread local variable.
40. */
41. public ThreadLocal() {
42. }
43.
44. /**
45. * Returns the value in the current thread's copy of this thread-local
46. * variable. Creates and initializes the copy if this is the first time
47. * the thread has called this method.
48. *
49. * @return the current thread's value of this thread-local
50. */
51. public T get() {
52. Thread t = Thread.currentThread();
53. ThreadLocalMap map = getMap(t);
54. if (map !
= null)
55. return (T)map.get(this);
56.
57. // Maps are constructed lazily. if the map for this thread
58. // doesn't exist, create it, with this ThreadLocal and its
59. // initial value as its only entry.
60. T value = initialValue();
61. createMap(t, value);
62. return value;
63. }
64.
65. /**
66. * Sets the current thread's copy of this thread-local variable
67. * to the specified value. Many applications will have no need for
68. * this functionality, relying solely on the {@link #initialValue}
69. * method to set the values of thread-locals.
70. *
71. * @param value the value to be stored in the current threads' copy of
72. * this thread-local.
73. */
74. public void set(T value) {
75. Thread t = Thread.currentThread();
76. ThreadLocalMap map = getMap(t);
77. if (map !
= null)
78. map.set(this, value);
79. else
80. createMap(t, value);
81. }
82.
83. /**
84. * Get the map associated with a ThreadLocal. Overridden in
85. * InheritableThreadLocal.
86. *
87. * @param t the current thread
88. * @return the map
89. */
90. ThreadLocalMap getMap(Thread t) {
91. return t.threadLocals;
92. }
93.
94. /**
95. * Create the map associated with a ThreadLocal. Overridden in
96. * InheritableThreadLocal.
97. *
98. * @param t the current thread
99. * @param firstValue value for the initial entry of the map
100. * @param map the map to store.
101. */
102. void createMap(Thread t, T firstValue) {
103. t.threadLocals = new ThreadLocalMap(this, firstValue);
104. }
105.
106. .......
107.
108. /**
109. * ThreadLocalMap is a customized hash map suitable only for
110. * maintaining thread local values. No operations are exported
111. * outside of the ThreadLocal class. The class is package private to
112. * allow declaration of fields in class Thread. To help deal with
113. * very large and long-lived usages, the hash table entries use
114. * WeakReferences for keys. However, since reference queues are not
115. * used, stale entries are guaranteed to be removed only when
116. * the table starts running out of space.
117. */
118. static class ThreadLocalMap {
119.
120. ........
121.
122. }
123.
124.}
可以看到ThreadLocal类中的变量只有这3个int型:
java代码:
查看复制到剪贴板打印
1.private final int threadLocalHashCode = nextHashCode();
2.private static int nextHashCode = 0;
3.private static final int HASH_INCREMENT = 0x61c88647;
而作为ThreadLocal实例的变量只有threadLocalHashCode这一个,nextHashCode和HASH_INCREMENT是ThreadLocal类的静态变量,实际上HASH_INCREMENT是一个常量,表示了连续分配的两个ThreadLocal实例的threadLocalHashCode值的增量,而nextHashCode的表示了即将分配的下一个ThreadLocal实例的threadLocalHashCode的值。
可以来看一下创建一个ThreadLocal实例即newThreadLocal()时做了哪些操作,从上面看到构造函数ThreadLocal()里什么操作都没有,唯一的操作是这句:
java代码:
查看复制到剪贴板打印
1.private final int threadLocalHashCode = nextHashCode();
那么nextHashCode()做了什么呢:
java代码:
查看复制到剪贴板打印
1.private static synchronized int nextHashCode() {
2. int h = nextHashCode;
3. nextHashCode = h + HASH_INCREMENT;
4. return h;
5.}
就是将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.public class Thread implements Runnable {
2. ......
3.
4. /* ThreadLocal values pertaining to this thread. This map is maintained
5. * by the ThreadLocal class. */
6. ThreadLocal.ThreadLocalMap threadLocals = null;
7. ......
8.}
再看这句:
java代码:
查看复制到剪贴板打印
1.if (map !
= null)
2. map.set(this, value);
也就是将该ThreadLocal实例作为key,要保持的对象作为值,设置到当前线程的ThreadLocalMap中,get()方法同样大家看了代码也就明白了,ThreadLocalMap类的代码太多了,我就不帖了,自己去看源码吧。
1.区别ThreadLocal与synchronized
∙ThreadLocal是一个线程隔离(或者说是线程安全)的变量存储的管理实体(注意:
不是存储用的),它以Java类方式表现;
∙synchronized是Java的一个保留字,只是一个代码标识符,它依靠JVM的锁机制来实现临界区的函数、变量在CPU运行访问中的原子性。
两者的性质、表现及设计初衷不同,因此没有可比较性。
2.理解ThreadLocal中提到的变量副本
事实上,我们向ThreadLocal中set的变量不是由ThreadLocal来存储的,而是Thread线程对象自身保存。
当用户调用ThreadLocal对象的set(Objecto)时,该方法则通过Thread.currentThread()获取当前线程,将变量存入Thread中的一个Map内,而Map的Key就是当前的ThreadLocal实例。
请看源码,这是最主要的两个函数,能看出ThreadLocal与Thread的调用关系:
java代码:
查看复制到剪贴板打印
1.public void set(T value) {
2. Thread t = Thread.currentThread();
3. ThreadLocalMap map = getMap(t);
4. if (map !
= null)
5. map.set(this, value);
6. else
7. createMap(t, value);
8.}
9.
10.ThreadLocalMap getMap(Thread t) {
11. return t.threadLocals;
12.}
(有兴趣的朋友可以阅读Java的ThreadLocal源码)因此,我们可以知道,所谓的变量副本,即是对ObjectReference(对象引用)
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- Threadlocal