关于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