首先有几点需要大家清楚的：

1、  ThreadLocal只是对需要存储的对象的管理，而存储实际是由当前Thread负责。个人理解为ThreadLocal是一个操作Thread. threadLocals 的工具。

2、  使用ThreadLocal可以使对象达到线程隔离的目的。同一个ThreadLocal操作不同的Thread，实质是各个Thread对自己的变量操作。

3、  为什么要使用ThreadLocal，个人感觉有两个原因，1是与其它线程的隔离，2是可以在一个线程的生命周期中使用同一个对象，达到对象传递的作用。这样的好处是可以减少dal访问或者ws调用。

我这里列出一个用到ThreadLocal的例子，主要的作用是使用ThreadLocal记录用户信息以及记录用户的执行时间。这在实际应用中，可以映射为全局记录用户的权限，以及使用Threadlocal对系统的性能做一些分析等。。

首先有两个对象，一个是用户对象

Java代码  

1. // 简单记录用户是否可以访问，可以用于全局权限控制等  
2. class User {  
3.     private String name;  
4.     private boolean isAllow;  
5.     public User(String name, boolean isAllow) {  
6.         this.name = name;  
7.         this.isAllow = isAllow;  
8.     }  
9.     public String getName() {  
10.         return name;  
11.     }  
12.     public boolean isAllow() {  
13.         return isAllow;  
14.     }  
15.     @Override  
16.     public String toString() {  
17.         return "用户名：" + name + "\t 是否允许访问：" + isAllow;  
18.     }  
19. }  

另一个是消费时间对象

Java代码  

1. // 用于记录每一步骤耗时…,可以用于每一步的性能分析  
2. class TimeConsumer {  
3.     // 名称  
4.     private String name;  
5.     // 耗时数据列表  
6.     private List<Long> steps;  
7.     public TimeConsumer(String name, long start) {  
8.         this.name = name;  
9.         steps = new ArrayList<Long>();  
10.         steps.add(start);  
11.     }  
12.     public void andStep(long step) {  
13.         steps.add(step);  
14.     }  
15.     @Override  
16.     public String toString() {  
17.         StringBuffer br = new StringBuffer("操作[" + name + "]共有"  
18.                 + (steps.size() - 1) + "步\n");  
19.         for (int i = 1; i < steps.size(); i++) {  
20.             br.append("\t|--耗时[" + (steps.get(i) - steps.get(0))  
21.                     + "ms]\n");  
22.         }  
23.         br.append("\n");  
24.         return br.toString();  
25.     }  
26. }  

接下来，建立一个对这两个对象管理的ThreadLocal的类

Java代码  

1. // threadlocal 管理类  
2. class MyThreadLocal {  
3.     // 用于全局记录user访问权限  
4.     private ThreadLocal<User> userLocal;  
5.     // 用于全局记录用户每一步的耗时  
6.     private ThreadLocal<TimeConsumer> timeLocal;  
7.     private static MyThreadLocal local = new MyThreadLocal();  
8.     private MyThreadLocal() {  
9.         userLocal = new ThreadLocal<User>();  
10.         timeLocal = new ThreadLocal<TimeConsumer>();  
11.     }  
12.     public static MyThreadLocal getInstanse() {  
13.         return local;  
14.     }  
15.     public void addUser(User user) {  
16.         userLocal.set(user);  
17.     }  
18.     public User getUser() {  
19.         return userLocal.get();  
20.     }  
21.     public void addTime(TimeConsumer timeConsumer) {  
22.         timeLocal.set(timeConsumer);  
23.     }  
24.     public void addTime(long l) {  
25.         TimeConsumer time = timeLocal.get();  
26.         timeLocal.remove();  
27.         time.andStep(l);  
28.         timeLocal.set(time);  
29.     }  
30.     public TimeConsumer getTime() {  
31.         return timeLocal.get();  
32.     }  
33. }  

接下来就可以对Threadlocal进行测试了。为了模拟多线程，我这里自己实现了多线程

Java代码  

1. public class CoreThreadLocal {  
2.     public static void main(String[] args) {  
3.         new Thread(new TestRunnable("name1", 1000L, true)).start();  
4.         new Thread(new TestRunnable("name2", 700L, true)).start();  
5.         new Thread(new TestRunnable("name3", 888, false)).start();  
6.     }  
7. }  
8.   
9. // 用于测试，多线程实现  
10. class TestRunnable implements Runnable {  
11.     String name;  
12.     long l;  
13.     boolean isAllow;  
14.   TestRunnable(String name, long l, boolean isAllow) {  
15.         this.name = name;  
16.         this.l = l;  
17.         this.isAllow = isAllow;  
18.     }  
19.     public void run() {  
20.         MyThreadLocal local = MyThreadLocal.getInstanse();  
21.         local.addUser(new User(name, isAllow));  
22.         local.addTime(new TimeConsumer(name, System.currentTimeMillis()));  
23.         // 做某个业务，并记录时间  
24.         doThings(l);  
25.         local.addTime(System.currentTimeMillis());  
26.         // 做某个业务，并记录时间  
27.         doThings(l);  
28.         local.addTime(System.currentTimeMillis());  
29.         // 业务做完，打印日志  
30.         System.out.println(local.getUser());  
31.         System.out.println(local.getTime());  
32.     }  
33.     // 模拟具体业务的处理步骤  
34.     private void doThings(long l) {  
35.         try {  
36.             Thread.sleep(l);  
37.         } catch (InterruptedException e) {  
38.             e.printStackTrace();  
39.         }  
40.     }  
41. }  

运行上面的程序得到结果如下：

Java代码  

1. 用户名：name2    是否允许访问：true  
2. 操作[name2]共有2步  
3.     |--耗时[703ms]  
4.     |--耗时[1406ms]  
5.   
6.   
7. 用户名：name3    是否允许访问：false  
8. 操作[name3]共有2步  
9.     |--耗时[891ms]  
10.     |--耗时[1781ms]  
11.   
12.   
13. 用户名：name1    是否允许访问：true  
14. 操作[name1]共有2步  
15.     |--耗时[1000ms]  
16.     |--耗时[2000ms]  

通过上面的测试程序，可以大概了解ThreadLocal的使用方法以及作用。

如果要深入使用，建议还是看下源码吧…