关于ThreadLocal的理解

当多个线程间共享变量时，通常都需要使用同步策略来保证变量的内存可见性。一种避免使用同步的方式就是不在线程间共享数据。

如果仅在单线程内访问数据，就不需要同步。这种技术被称为线程封闭，它是实现线程安全性的最简单方式之一。

维持线程封闭性的一种方式就是使用ThreadLocal，通过ThreadLocal维护的变量(非单实例变量和非原子变量)都是线程私有的，不是共享的。ThreadLocal提供了get和set等方法，这些方法操作的都是每个线程自己的变量值，不会对其它线程造成影响。这样就像我们在单线程中使用一个变量一样，不会有线程安全问题。

public class ThreadLocalTest extends Thread{

public void run() {
for (int i=0; i < 10; i++) {
System.out.println(IdGenerator.getCurrentId());
}
}

public static void main(String args[]) {
ThreadLocalTest t1 = new ThreadLocalTest();
ThreadLocalTest t2 = new ThreadLocalTest();

//t1线程和t2线程中都有自己的val变量值，互不影响
t1.start();
t2.start();
}

}

/**
* 这个类的作用是给每个线程产生独立的递增id，各个线程之间互相不影响
*
* 为了说明问题，假设每个线程都有一个变量val，用来保存各个线程的当前id值
*/
class IdGenerator {

//num变量中保存着每个线程的val变量，初始值为10000
private static final ThreadLocal<Integer> num = new ThreadLocal<Integer>() {
@Override
protected Integer initialValue() {
return 10000; //假设这个变量的变量名是val
}
};

public static int getCurrentId() {

//get()和set()方法都是获取每个线程自己的val值，不会有线程安全问题
num.set(num.get() + 1);
return num.get();
}
}

上例中我们假设的val变量是一个Integer型的，Integer类不是单例模式的，如果是一个单例变量就要注意了，这时每个线程操作的还是同一个实例，会有线程安全问题，必要的情况下需要使用同步，比如下面这个例子

public class ThreadLocalTest1 extends Thread{

public void run() {

Singleton singleton = SingletonManager.getCurrentThreadSingleton();
//如果这里对singleton进行一些操作（比如set()），需要考虑使用同步机制
System.out.println(singleton.getName());
}

public static void main(String args[]) throws InterruptedException {
ThreadLocalTest1 t1 = new ThreadLocalTest1();
ThreadLocalTest1 t2 = new ThreadLocalTest1();

t1.start();

//在主线程中修改主线程自己的Singleton对象，会导致t2线程的Singleton对象也被修改，因为它们是同一个单实例对象
Thread.sleep(10); //给t1线程足够的运行时间
Singleton singleton = SingletonManager.getCurrentThreadSingleton();
singleton.setName("tom");

t2.start();
}
}

/**
* 这个类的作用是为每个线程保存自己的Singleton对象
* 但由于Singleton类本身是单例模式，所以其实每个线程自己的
* Singleton对象都是相同的
*/
class SingletonManager {

private static final ThreadLocal<Singleton> manager = new ThreadLocal<Singleton>() {
@Override
protected Singleton initialValue() {
return Singleton.getInstance();
}
};

public static Singleton getCurrentThreadSingleton() {
return manager.get();
}
}

/**
* 一个单例模式的类
*/
class Singleton {

private static Singleton st = new Singleton();

//一个普通成员变量
private String name;

private Singleton() {}

public static Singleton getInstance() {
return st;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}
}

对于原子变量的情况和单实例变量情况相似，当然在使用同步的方式上可能有些差别。

那么ThreadLocal是用来解决多线程中共享变量的问题的吗？我认为不是，ThreadLocal的本意应该是为了避免在多线程之间共享数据，从而回避掉线程间的同步问题，

就像第一个例子那样。对于第二个例子只是为了说明单实例变量的问题，实际编码中应该避免，画蛇添足的感觉。

关于ThreadLocal的原理阐述见 http://www.iteye.com/topic/103804