java 多线程初学（ThreadLocal类学习）

ThreadLocal是解决线程安全问题一个很好的思路，它通过为每个线程提供一个独立的变量副本解决了变量并发访问的冲突问题。在很多情况下，ThreadLocal比直接使用synchronized同步机制解决线程安全问题更简单，更方便，且结果程序拥有更高的并发性。

        在Java的多线程编程中，为保证多个线程对共享变量的安全访问，通常会使用synchronized来保证同一时刻只有一个线程对共享变量进行操作。但在有些情况下，synchronized不能保证多线程对共享变量的正确读写。例如类有一个类变量，该类变量会被多个类方法读写，当多线程操作该类的实例对象时，如果线程对类变量有读取、写入操作就会发生类变量读写错误，即便是在类方法前加上synchronized也无效，因为同一个线程在两次调用方法之间时锁是被释放的，这时其它线程可以访问对象的类方法，读取或修改类变量。这种情况下可以将类变量放到ThreadLocal类型的对象中，使变量在每个线程中都有独立拷贝，不会出现一个线程读取变量时而被另一个线程修改的现象。

     下面是ThreadLocal的实现原理

 

public class SimpleThreadLocal {
　　private Map valueMap = Collections.synchronizedMap(new HashMap());
　　public void set(Object newValue) {
　　valueMap.put(Thread.currentThread(), newValue);①键为线程对象，值为本线程的变量副本
　　}
　　public Object get() {
　　Thread currentThread = Thread.currentThread();
　　Object o = valueMap.get(currentThread);②返回本线程对应的变量
　　if (o == null && !valueMap.containsKey(currentThread)) {③如果在Map中不存在，放到Map
　　中保存起来。
　　o = initialValue();
　　valueMap.put(currentThread, o);
　　}
　　return o;
　　}
　　public void remove() {
　　valueMap.remove(Thread.currentThread());
　　}
　　public Object initialValue() {
　　return null;
　　}
　　}

 

 其中 initalValue是protected的，留给子类实现，默认返回null值。

 

一个demo

 

package TreaditionThread;

import java.util.HashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadLocalTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ExecutorService exec = Executors.newCachedThreadPool();
		for (int i = 0; i < 2; i++) {
			exec.execute(new Task());
		}
		exec.shutdown();
	}

}

class Task implements Runnable {

	public void run() {
		// TODO Auto-generated method stub
		MyThreadLocalData.getInstanceMap().put("key",
				Thread.currentThread().getName());
		new A().get();
		new B().get();
	}

}

class A {
	public void get() {
		HashMap<String, Object> m = MyThreadLocalData.getInstanceMap();
		if (m != null) {
			System.out.println("A:" + m.get("key"));
		}
	}
}

class B {
	public void get() {
		HashMap<String, Object> m = MyThreadLocalData.getInstanceMap();
		if (m != null) {
			System.out.println("B:" + m.get("key"));
		}
	}
}

class MyThreadLocalData {
	// 每个线程的专属map
	private static ThreadLocal<HashMap<String, Object>> data = new ThreadLocal<HashMap<String, Object>>();

	public static HashMap<String, Object> getInstanceMap() {
		HashMap<String, Object> m = data.get();
		if (m == null) {
			m = new HashMap<String, Object>();
			data.set(m);
		}
		return data.get();
	}
}

 output:

A:pool-1-thread-1

A:pool-1-thread-2

B:pool-1-thread-1

B:pool-1-thread-2