執行緒範圍內共享變數

HashTable方式實現

在開發中經常會遇到一種情況:有一個變數會被多個執行緒訪問，但是要確保同個執行緒內訪問的是同一個物件，Hashtable方式實現程式碼如下:

public class ThreadExample5 {
    private static Map<Thread, Integer> threadData = new Hashtable<Thread, 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);
                    threadData.put(Thread.currentThread(), data);
                    new
 
 A().get();
                    new B().get();
                }
            }).start();
        }
    }

    static class A {
        public void get() {
            System.out.println(threadData);
            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);
        }
    }
}

注意這裡用到的是Hashtable(執行緒安全)來區分每個執行緒，網上很多資料寫的都是用HashMap(執行緒不安全)，我經過實際測試發現此處用HashMap是有問題的。HashMap底層是一個Entry陣列當發生hash衝突的時候HashMap是採用連結串列的方式來解決的，在對應的陣列位置存放連結串列的頭結點，對連結串列而言新加入的節點會從頭結點加入，假如A執行緒和B執行緒同時對同一個陣列位置進行新增資料，兩個執行緒會同時得到現在的頭結點，然後A寫入新的頭結點之後B也寫入新的頭結點，那B的寫入操作就會覆蓋A的寫入操作造成A的寫入操作丟失

ThreadLocal方式實現

public class ThreadExample6 {
    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。如下為解決方案:

public class ThreadExample7 {
    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();
                    MyThreadScopeData.getThreadInstance().setName("name:名字" + data);
                    MyThreadScopeData.getThreadInstance().setAge(data);
                    new A().get();
                    new B().get();
                }
            }).start();
        }
    }

    static class A {
        public void get() {
            MyThreadScopeData myData = MyThreadScopeData.getThreadInstance();
            System.out.println("A from " + Thread.currentThread().getName() + " getMyData: " + myData.getName() + "," + myData.getAge());
        }
    }

    static class B {
        public void get() {
            MyThreadScopeData myData = MyThreadScopeData.getThreadInstance();
            System.out.println("B from " + Thread.currentThread().getName() + " getMyData: " + myData.getName() + "," + myData.getAge());
        }
    }
}

class MyThreadScopeData {
    private static ThreadLocal<MyThreadScopeData> map = new ThreadLocal<MyThreadScopeData>();

    private 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;
    }
}

此處解決的方式是用一個物件封裝需要執行緒共享的物件，然後再把該物件繫結到ThreadLocal中, 實現執行緒範圍內變數共享。對構造方法進行私有化並且getThreadInstance()進行同步，目的是確保整個執行緒只有一個MyThreadScopeData例項