ThreadLocal使用实例

ThreadLocal为每一个线程都提供了变量的副本，使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享 

Java代码  

1. package test;  
2.   
3. import java.util.Random;  
4.   
5. class Student {  
6.     private int age;  
7.   
8.     public int getAge() {  
9.         return age;  
10.     }  
11.   
12.     public void setAge(int age) {  
13.         this.age = age;  
14.     }  
15. }  
16.   
17. public class TestThreadLocal implements Runnable {  
18.   
19.     ThreadLocal studentLocal = new ThreadLocal();  
20.   
21.     public static void main(String[] args) {  
22.         TestThreadLocal t = new TestThreadLocal();  
23.         new Thread(t, "t1").start();  
24.         new Thread(t, "t2").start();  
25.     }  
26.   
27.     @Override  
28.     public void run() {  
29.         accessStudent();  
30.     }  
31.   
32.     private void accessStudent() {  
33.         Student s = this.getStudent();  
34.         Random random = new Random();  
35.         int age = random.nextInt(100);  
36.         System.out.println("current thread set age " + Thread.currentThread()  
37.                 + ":" + age);  
38.         s.setAge(age);  
39.         System.out.println("current thread first get age "  
40.                 + Thread.currentThread() + ":" + s.getAge());  
41.         try {  
42.             Thread.sleep(500);  
43.         } catch (InterruptedException e) {  
44.             // TODO Auto-generated catch block  
45.             e.printStackTrace();  
46.         }  
47.         System.out.println("current thread second get age "  
48.                 + Thread.currentThread() + ":" + s.getAge());  
49.     }  
50.   
51.     public Student getStudent() {  
52.         Student s = (Student) studentLocal.get();  
53.         if (s == null) {  
54.             s = new Student();  
55.             studentLocal.set(s);  
56.         }  
57.         return s;  
58.     }  
59. }  

概括起来说，对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。 

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

转载于： http://0414.iteye.com/blog/2072256