ThreadLocal与Synchronized的用法

一.ThreadLocal的用法

ThreadLocal的实现：

[java]  view plain copy

1. package com.sodao.lucene;     
2.     
3. import java.util.Random;     
4.     
5. public class ThreadLocalTest implements Runnable{     
6.          
7.     ThreadLocal<Studen> studenThreadLocal = new ThreadLocal<Studen>();     
8.     
9.     @Override    
10.     public void run() {     
11.         String currentThreadName = Thread.currentThread().getName();     
12.         System.out.println(currentThreadName + " is running...");     
13.         Random random = new Random();     
14.         int age = random.nextInt(100);     
15.         System.out.println(currentThreadName + " is set age: "  + age);     
16.         Studen studen = getStudent(); //通过这个方法，为每个线程都独立的new一个student对象，每个线程的的student对象都可以设置不同的值     
17.         studen.setAge(age);     
18.         System.out.println(currentThreadName + " is first get age: " + studen.getAge());     
19.         try {     
20.             Thread.sleep(500);     
21.         } catch (InterruptedException e) {     
22.             e.printStackTrace();     
23.         }     
24.         System.out.println( currentThreadName + " is second get age: " + studen.getAge());     
25.              
26.     }     
27.          
28.     private Studen getStudent() {     
29.         Studen studen = studenThreadLocal.get();     
30.         if (null == studen) {     
31.             studen = new Studen();     
32.             studenThreadLocal.set(studen);     
33.         }     
34.         return studen;     
35.     }     
36.     
37.     public static void main(String[] args) {     
38.         ThreadLocalTest t = new ThreadLocalTest();     
39.         Thread t1 = new Thread(t,"Thread A");     
40.         Thread t2 = new Thread(t,"Thread B");     
41.         t1.start();     
42.         t2.start();     
43.     }     
44.          
45. }     
46.     
47. class Studen{     
48.     int age;     
49.     
50.     public int getAge() {     
51.         return age;     
52.     }     
53.     
54.     public void setAge(int age) {     
55.         this.age = age;     
56.     }     
57.          
58. }    

Synchronized的实现：

[java]  view plain copy

1. package com.sodao.lucene;     
2.     
3. import java.util.Random;     
4.     
5. public class MultiThreadTest  implements Runnable{     
6.          
7.     Studen studen = new Studen();     
8.          
9.     @Override    
10.     public void run() {     
11.         String currentThreadName = Thread.currentThread().getName();     
12.         System.out.println(currentThreadName + " is running ....");     
13.         //同步     
14.         synchronized (studen) {     
15.             Random random = new Random();     
16.             int age = random.nextInt(100);     
17.             studen.setAge(age);     
18.             System.out.println(currentThreadName + " is set age: " + age);     
19.             System.out.println(currentThreadName + "is first get age: " + studen.getAge() );     
20.             try {     
21.                 Thread.sleep(500);     
22.             } catch (InterruptedException e) {     
23.                 e.printStackTrace();     
24.             }     
25.             System.out.println(currentThreadName + " is second get age: " + studen.getAge() );     
26.         }     
27.     }     
28.          
29.     public static void main(String[] args) {     
30.         MultiThreadTest m = new MultiThreadTest();     
31.         Thread t1 = new Thread(m,"Thread A");     
32.         Thread t2 = new Thread(m,"Thread B");     
33.         t1.start();     
34.         t2.start();     
35.     }     
36. }     
37.     
38. class Student {     
39.     int age;     
40.     
41.     public int getAge() {     
42.         return age;     
43.     }     
44.     
45.     public void setAge(int age) {     
46.         this.age = age;     
47.     }     
48.          
49. }    

以上2中方法都实现的功能相同，但方法不一样 

ThreadLocal使用场合主要解决多线程中数据数据因并发产生不一致问题。ThreadLocal为每个线程的中并发访问的数据提供一个副本，通过访问副本来运行业务，这样的结果是耗费了内存，单大大减少了线程同步所带来性能消耗，也减少了线程并发控制的复杂度。 

ThreadLocal不能使用原子类型，只能使用Object类型。ThreadLocal的使用比synchronized要简单得多。 

ThreadLocal和Synchonized都用于解决多线程并发访问。但是ThreadLocal与synchronized有本质的区别。synchronized是利用锁的机制，使变量或代码块在某一时刻只能被一个线程访问。而ThreadLocal为每一个线程都提供了变量的副本，使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。而Synchronized却正好相反，它用于在多个线程间通信时能够获得数据共享。 

Synchronized用于线程间的数据共享，而ThreadLocal则用于线程间的数据隔离。 

当然ThreadLocal并不能替代synchronized,它们处理不同的问题域。Synchronized用于实现同步机制，比ThreadLocal更加复杂。 

ThreadLocal使用的一般步骤： 

1、在多线程的类（如ThreadDemo类）中，创建一个ThreadLocal对象threadXxx，用来保存线程间需要隔离处理的对象xxx。 
2、在ThreadDemo类中，创建一个获取要隔离访问的数据的方法getXxx()，在方法中判断，若ThreadLocal对象为null时候，应该new()一个隔离访问类型的对象，并强制转换为要应用的类型。 
3、在ThreadDemo类的run()方法中，通过getXxx()方法获取要操作的数据，这样可以保证每个线程对应一个数据对象，在任何时刻都操作的是这个对象。

 

Come From：http://gcgmh.javaeye.com/blog/455940

 

二.ThreadLocal的实现原理：

[java]  view plain copy

1. public class ThreadLocal     
2. {     
3. 　private Map values = Collections.synchronizedMap(new HashMap());     
4. 　public Object get()     
5. 　{     
6. 　　Thread curThread = Thread.currentThread();      
7. 　　Object o = values.get(curThread);      
8. 　　if (o == null && !values.containsKey(curThread))     
9. 　　{     
10. 　　　o = initialValue();     
11. 　　　values.put(curThread, o);      
12. 　　}     
13. 　　return o;      
14. 　}     
15.     
16. 　public void set(Object newValue)     
17. 　{     
18. 　　values.put(Thread.currentThread(), newValue);     
19. 　}     
20.     
21. 　public Object initialValue()     
22. 　{     
23. 　　return null;      
24. 　}     
25. }    

由此可见，ThreadLocal通过一个Map来为每个线程都持有一个变量副本。这个map以当前线程为key。与synchronized相比，ThreadLocal是以空间换时间的策略来实现多线程程序。 

Synchronized还是ThreadLocal? 
ThreadLocal以空间换取时间，提供了一种非常简便的多线程实现方式。因为多个线程并发访问无需进行等待，所以使用ThreadLocal会获得更大的性能。虽然使用ThreadLocal会带来更多的内存开销，但这点开销是微不足道的。因为保存在ThreadLocal中的对象，通常都是比较小的对象。另外使用ThreadLocal不能使用原子类型，只能使用Object类型。ThreadLocal的使用比synchronized要简单得多。 
ThreadLocal和Synchonized都用于解决多线程并发访问。但是ThreadLocal与synchronized有本质的区别。synchronized是利用锁的机制，使变量或代码块在某一时该只能被一个线程访问。而ThreadLocal为每一个线程都提供了变量的副本，使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。而Synchronized却正好相反，它用于在多个线程间通信时能够获得数据共享。 
Synchronized用于线程间的数据共享，而ThreadLocal则用于线程间的数据隔离。 
当然ThreadLocal并不能替代synchronized,它们处理不同的问题域。Synchronized用于实现同步机制，比ThreadLocal更加复杂。

Come From: http://www.javaeye.com/topic/81936

                    http://www.javaeye.com/topic/103804

                    http://blog.csdn.net/yangairong1984/archive/2008/04/15/2294572.aspx

http://www.blogjava.net/jspark/archive/2006/08/01/61165.html

最近由于需要用到ThreadLocal，在网上搜索了一些相关资料，发现对ThreadLocal经常会有下面几种误解

 一、ThreadLocal是java线程的一个实现
      ThreadLocal的确是和java线程有关，不过它并不是java线程的一个实现，它只是用来维护本地变量。针对每个线程，提供自己的变量版本，主要是为了避免线程冲突，每个线程维护自己的版本。彼此独立，修改不会影响到对方。

 二、ThreadLocal是相对于每个session的

        ThreadLocal顾名思义，是针对线程。在java web编程上，每个用户从开始到会话结束，都有自己的一个session标识。但是ThreadLocal并不是在会话层上。其实，Threadlocal是独立于用户session的。它是一种服务器端行为，当服务器每生成一个新的线程时，就会维护自己的ThreadLocal。对于这个误解，个人认为应该是开发人员在本地基于一些应用服务器测试的结果。众所周知，一般的应用服务器都会维护一套线程池，也就是说，对于每次访问，并不一定就新生成一个线程。而是自己有一个线程缓存池。对于访问，先从缓存池里面找到已有的线程，如果已经用光，才去新生成新的线程。所以，由于开发人员自己在测试时，一般只有他自己在测，这样服务器的负担很小，这样导致每次访问可能是共用同样一个线程，导致会有这样的误解：每个session有一个ThreadLocal

 三、ThreadLocal是相对于每个线程的，用户每次访问会有新的ThreadLocal

  理论上来说，ThreadLocal是的确是相对于每个线程，每个线程会有自己的ThreadLocal。但是上面已经讲到，一般的应用服务器都会维护一套线程池。因此，不同用户访问，可能会接受到同样的线程。因此，在做基于TheadLocal时，需要谨慎，避免出现ThreadLocal变量的缓存，导致其他线程访问到本线程变量

 四、对每个用户访问，ThreadLocal可以多用
        可以说，ThreadLocal是一把双刃剑，用得来的话可以起到非常好的效果。但是，ThreadLocal如果用得不好，就会跟全局变量一样。代码不能重用，不能独立测试。因为，一些本来可以重用的类，现在依赖于ThreadLocal变量。如果在其他没有ThreadLocal场合，这些类就变得不可用了。个人觉得ThreadLocal用得很好的几个应用场合，值得参考

  1、存放当前session用户：quake want的jert

  2、存放一些context变量，比如webwork的ActionContext

  3、存放session，比如Spring hibernate orm的session