线程范围内共享数据(二)

本篇讲述通过ThreadLocal类来实现线程范围内共享数据

代码如下：

public class ThreadLocalShare {
	
	private static ThreadLocal<Integer> threadLocal=new ThreadLocal<Integer>();
	
	public static void main(String[] args) {
		
			for(int i=0;i<2;i++){
				new Thread(new Runnable(){
					@Override
					public void run() {
					    int data = new Random().nextInt();
						System.out.println(Thread.currentThread().getName() 
								+ " has put data :" + data);
						threadLocal.set(data);
						new A().get();
						new B().get();
					}
				}).start();
			}
		}
		
		static class A{
			public void get(){
				int data=threadLocal.get();
				System.out.println("A from " + Thread.currentThread().getName() 
						+ " get data :" + data);
			}
		}
		
		static class B{
			public void get(){	
				int data=threadLocal.get();
				System.out.println("B from " + Thread.currentThread().getName() 
						+ " get data :" + data);
			}	
		}
}

输出结果为：

Thread-0 has put data :1800795006
Thread-1 has put data :357546823
A from Thread-0 get data :1800795006
A from Thread-1 get data :357546823
B from Thread-0 get data :1800795006
B from Thread-1 get data :357546823

实现了不同模块在同一线程中运行时数据的共享。

注意：

1、ThreadLocal对象的set(param)方法相当于HashMap的put()方法，原理类似于往map中放入一条记录，key值为各自的线程，value值为set(param)方法中的参数。

当线程结束时，可调用ThreadLocal.clear()方法，以便释放内存。也可等线程结束后自动自动释放存。

2、一个ThreadLocal代表一个变量，故里面只能存放一个变量对应的数据；当存在多个变量时需要线程共享，则可定义对象来封装变量，然后在ThreadLocal中存储对象即可。

例子如下：

public class ThreadLocalScope {

	private static ThreadLocal<Integer> x = new ThreadLocal<Integer>();
	private static ThreadLocal<MyThreadScopeData> myThreadScopeData = new ThreadLocal<MyThreadScopeData>();
	public static void main(String[] args) {
		for(int i=0;i<2;i++){
			new Thread(new Runnable(){
				@Override
				public void run() {
					int data = new Random().nextInt();
					System.out.println(Thread.currentThread().getName() 
							+ " has put data :" + data);
					x.set(data);
					MyThreadScopeData.getThreadInstance().setName("name" + data);
					MyThreadScopeData.getThreadInstance().setAge(data);
					new A().get();
					new B().get();
				}
			}).start();
		}
	}
	
	static class A{
		public void get(){
			int data = x.get();
			System.out.println("A from " + Thread.currentThread().getName() 
					+ " get data :" + data);
			MyThreadScopeData myData = MyThreadScopeData.getThreadInstance();
			System.out.println("A from " + Thread.currentThread().getName() 
					+ " getMyData: " + myData.getName() + "," +
					myData.getAge());
		}
	}
	
	static class B{
		public void get(){
			int data = x.get();			
			System.out.println("B from " + Thread.currentThread().getName() 
					+ " get data :" + data);
			MyThreadScopeData myData = MyThreadScopeData.getThreadInstance();
			System.out.println("B from " + Thread.currentThread().getName() 
					+ " getMyData: " + myData.getName() + "," +
					myData.getAge());			
		}		
	}
}

class MyThreadScopeData{
	private MyThreadScopeData(){}
	public static MyThreadScopeData getThreadInstance(){
		MyThreadScopeData instance = map.get();
		if(instance == null){
			instance = new MyThreadScopeData();
			map.set(instance);
		}
		return instance;
	}
	//private static MyThreadScopeData instance = null;//new MyThreadScopeData();  
	private static ThreadLocal<MyThreadScopeData> map = new ThreadLocal<MyThreadScopeData>();
	
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}

在应用上来说，线程范围内共享对象数据的应用明显多于单个属性变量的共享应用。