ThreadLocal和线程的普通成员变量究竟有什么区别？

问题由来：

最近在看多线程的知识，有提到ThreadLocal是一种线程局部变量，每个线程都有相对独立的变量初始化拷贝，是一种以空间换时间的做法。
那么问题来了，
1. 它和在线程代码里直接写一个普通成员变量有什么区别呢？
2. 它真的能“以空间换时间”吗？

问题1的思考：

问题：它和在线程代码里直接写一个普通成员变量有什么区别呢？
ThreadLocal和线程的普通成员变量都是线程安全的，我觉得这是毫无疑问的。因为每个线程都有一个threadLocals，这个里面就是一个ThreadLocalMap,而ThreadLocal对象就是map的key。
这样就可以写出非常优雅的代码了，因为传入一个外部的ThreadLocal对象，或者是线程的static对象，只要你没有对它进行过初始化，那么你通过threadLocal.get()出来的就是null。这就表明，一个threadLocal对象在其他线程里面调用了set()赋值，并不会影响到另一个线程。
话又说回来了，ThreadLocal和线程的普通成员变量到底有什么区别呢？
我的理解是，普通成员变量的初始化对这个线程本身是高度耦合的，我必须要知道这个线程是哪个，必须知道这个普通成员变量名是什么才能进行赋值。
而ThreadLocal则不需要，只需要声明好泛型的类型，定义好初始化函数，或者在自己定义的getValue方法里判断ThreadLocal.get()==null?是则调用ThreadLocal.set()方法进行初始化。
就比如这个例子：

public class MyThreadLocal { 
        //定义了一个ThreadLocal变量，用来保存int或Integer数据 
        private ThreadLocal<Integer> tl = new ThreadLocal<Integer>() { 
                @Override 
                protected Integer initialValue() { 
                        return 0; 
                } 
        }; 
        public Integer getNextNum() { 
                //将tl的值获取后加1，并更新设置t1的值 
                tl.set(tl.get() + 1); 
                return tl.get(); 
        } 
}

/** 
* 测试线程 
*/ 
public class TestThread extends Thread { 
        private MyThreadLocal tlt = new MyThreadLocal(); 

        public TestThread(MyThreadLocal tlt) { 
                this.tlt = tlt; 
        } 

        @Override 
        public void run() { 
                for (int i = 0; i < 3; i++) { 
                        System.out.println(Thread.currentThread().getName() + "\t" + tlt.getNextNum()); 
                } 
        } 
}

/** 
* ThreadLocal测试 
* 
* @author leizhimin 2010-1-5 10:43:48 
*/ 
public class Test { 
        public static void main(String[] args) { 
                MyThreadLocal tlt = new MyThreadLocal(); 
                Thread t1 = new TestThread(tlt); 
                Thread t2 = new TestThread(tlt); 
                Thread t3 = new TestThread(tlt); 
                Thread t4 = new TestThread(tlt); 
                t1.start(); 
                t2.start(); 
                t3.start(); 
                t4.start(); 

        } 
}

测试结果：

Thread-0  1 
Thread-1  1 
Thread-0  2 
Thread-1  2 
Thread-0  3 
Thread-1  3 
Thread-2  1 
Thread-3  1 
Thread-2  2 
Thread-3  2 
Thread-2  3 
Thread-3  3 

由此可见，线程的代码里根本就不需要对ThreadLocal里的变量的初始化操心，这些都可以由外部的工具类完成，而工具类里也不需要管是哪个线程调用的。
我觉得这就是ThreadLocal最强大的地方！

问题2的思考：

问题：它真的能“以空间换时间”吗？
我觉得这个一空间换时间是针对使用static sycronized的变量而言的。
有的线程要用到数据库连接的condition,或者是session。这些都是线程不安全的，如果一个类只有一个全局的static变量，那么是一定要用同步来控制的。
那在高并发环境下的阻塞等待是不能容忍的。
所以使用ThreadLocal可以在每个线程都能初始化一下，就解决了异步问题。
所以我觉得ThreadLocal所说的“以空间换时间”，是针对static sycronized的方式来说的。

---

这就是我对ThreadLocal的思考，可能有些问题，还请高手指教。