執行緒範圍內共享變數要實現的效果為：

多個物件間共享同一執行緒內的變數

未實現執行緒共享變數的demo：

package cn.itcast.heima2;

import java.util.HashMap;
import java.util.Map;
import java.util.Random;

public class ThreadScopeShareData {

	private static int data = 0;
//	private static Map<Thread, Integer> threadData = new HashMap<Thread, Integer>();
	
	public static void main(String[] args) {
		//共啟動2個執行緒
		for(int i=0;i<2;i++){
			//啟動一個執行緒
			new Thread(new Runnable(){
				@Override
				public void run() {
					data = new Random().nextInt();
					System.out.println(Thread.currentThread().getName() 
							+ " has put data :" + data);
					//以當前執行緒為key值放入到map中，當取值時根據各自的執行緒取各自的資料
//					threadData.put(Thread.currentThread(), data);
					new A().get();
					new B().get();
				}
			}).start();
		}
	}
	
	static class A{
		public void get(){
//			int data = threadData.get(Thread.currentThread());
			System.out.println("A from " + Thread.currentThread().getName() 
					+ " get data :" + data);
		}
	}
	
	static class B{
		public void get(){
//			int data = threadData.get(Thread.currentThread());			
			System.out.println("B from " + Thread.currentThread().getName() 
					+ " get data :" + data);
		}		
	}
}
 

執行結果：

通過打印出的結果可以看出，當Thread-0獲取了一個隨機數，修改了data的值，正在睡眠的時候，Thread-1又獲取了一個隨機數，同樣修改了data的值，然後Thread-1呼叫了靜態內部類A和B的get方法，實際上此時的data已經是Thread-1拿到的隨機數了。

當然，我們可以通過增加synchronized加鎖來控制執行緒的執行。讓Thread-0執行完方法之前，Thread-1不能修改data的值。

此外，還可以使用另外幾種方法來獲取執行緒執行時變數賦予的真正值。

執行緒範圍內共享變數實現方式: 

Map實現方式：

package cn.itcast.heima2;

import java.util.HashMap;
import java.util.Map;
import java.util.Random;

public class ThreadScopeShareData {

	
	private static Map<Thread, Integer> threadData = new HashMap<Thread, Integer>();
	
	public static void main(String[] args) {
		//共啟動2個執行緒
		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);
					//以當前執行緒為key值放入到map中，當取值時根據各自的執行緒取各自的資料
					threadData.put(Thread.currentThread(), data);
					new A().get();
					new B().get();
				}
			}).start();
		}
	}
	
	static class A{
		public void get(){
			int data = threadData.get(Thread.currentThread());
			System.out.println("A from " + Thread.currentThread().getName() 
					+ " get data :" + data);
		}
	}
	
	static class B{
		public void get(){
			int data = threadData.get(Thread.currentThread());			
			System.out.println("B from " + Thread.currentThread().getName() 
					+ " get data :" + data);
		}		
	}
}
 

執行結果：

ThreadLocal方式：

package cn.itcast.heima2;

import java.util.Random;

public class ThreadLocalTest {

	private static ThreadLocal<Integer> x = 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);
					x.set(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);
		}
	}
	
	static class B{
		public void get(){
			int data = x.get();			
			System.out.println("B from " + Thread.currentThread().getName() 
					+ " get data :" + data);					
		}		
	}
}
 

存在的問題：一個ThreadLocal代表一個變數，故其中只能放一個數據，如果你有兩個變數要執行緒範圍內共享，則要定義兩個ThreadLocal。如下為解決方案：

擴充套件方式-單例方式處理物件：

package cn.itcast.heima2;

import java.util.Random;

public class ThreadLocalTest {

//	方式一
//	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);
//					方式一 ThreadLocal
//					x.set(data);
//					方式二 new物件方式，將多個屬性放到物件中
//					MyThreadScopeData myData = new MyThreadScopeData();
//					myData.setName("name" + data);
//					myData.setAge(data);
//					myThreadScopeData.set(myData);
//					方式三 使用單例模式
					MyThreadScopeData.getThreadInstance().setName("name" + data);
					MyThreadScopeData.getThreadInstance().setAge(data);
					
					new A().get();
					new B().get();
				}							
			}).start();
		}
	}
	
	static class A{
		public void get(){
//			方式一 ThreadLocal
//			int data = x.get();
//			System.out.println("A from " + Thread.currentThread().getName() 
//					+ " get data :" + data);
//			方式二 new物件方式，將多個屬性放到物件中
//			MyThreadScopeData myData = myThreadScopeData.get();;
//			System.out.println("A from " + Thread.currentThread().getName() 
//					+ " getMyData: " + myData.getName() + "," +
//					myData.getAge());
//			方式三 使用單例模式
			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.get();;
//			System.out.println("B from " + Thread.currentThread().getName() 
//					+ " getMyData: " + myData.getName() + "," +
//					myData.getAge());
			MyThreadScopeData myData = MyThreadScopeData.getThreadInstance();
			System.out.println("B from " + Thread.currentThread().getName() 
					+ " getMyData: " + myData.getName() + "," +
					myData.getAge());			
		}		
	}
}

class MyThreadScopeData{
	
	private MyThreadScopeData(){}
	
	private static MyThreadScopeData instance = null;//new MyThreadScopeData();
	
	private static ThreadLocal<MyThreadScopeData> map = new ThreadLocal<MyThreadScopeData>();
	
	public static /*synchronized*/ MyThreadScopeData getThreadInstance(){
		MyThreadScopeData instance = map.get();
		if(instance == null){
			instance = new MyThreadScopeData();
			map.set(instance);
		}
		return instance;
	}
	
	
	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;
	}
}

總結：

    synchronized和使用ThreadLocal均可以解決以上的問題，只是這是兩種不同的方式，synchronized是依賴鎖的機制一個執行完後另一個再執行。ThreadLocal會為每一個執行緒維護一個和該執行緒繫結的變數的副本，從而隔離了多個執行緒的資料，每一個執行緒都擁有自己的變數副本，從而也就沒有必要對該變數進行同步了。

    概括起來說，對於多執行緒資源共享的問題，同步機制採用了“以時間換空間”的方式，而ThreadLocal採用了“以空間換時間”的方式。前者僅提供一份變數，讓不同的執行緒排隊訪問，而後者為每一個執行緒都提供了一份變數，因此可以同時訪問而互不影響。

    當然ThreadLocal並不能替代同步機制，兩者面向的問題領域不同。同步機制是為了同步多個執行緒對相同資源的併發訪問，是為了多個執行緒之間進行通訊的有效方式；而ThreadLocal是隔離多個執行緒的資料共享，從根本上就不在多個執行緒之間共享資源(變數)，這樣當然不需要對多個執行緒進行同步了。

    ThreadLocal的應用：

    在業務邏輯層需要呼叫多個Dao層的方法，我們要保證事務（jdbc事務）就要確保他們使用的是同一個資料庫連線.那麼如何確保使用同一個資料庫連線呢？