Java中的線程--線程范圍內共享數據

　　接着學習Java中的線程，線程范圍內的共享數據！

一、線程范圍內的數據共享定義

對於相同的程序代碼，多個模塊在同一個線程中共享一份數據，而在另外線程中運行時又共享另外一份數據。

共享數據中存在的問題，代碼如下：

// A 和 B共享數據data，但是在這種情況下 會存在問題
public class ThreadScopeShareData {

    private static int data = 0;

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    data = new Random().nextInt();
                    System.out.println(Thread.currentThread().getName() + "has put data " + data);
                    new A().get();
                    new B().get();
                }
            }).start();
        }
    }

    static class A {
        public void get() {
            System.out.println("A from " + Thread.currentThread().getName() + "has put data " + data);
        }
    }

    static class B {
        public void get() {
            System.out.println("B from " + Thread.currentThread().getName() + "has put data " + data);
        }
    }

}

運行結果如下：（好像是有點亂七八糟的感覺）

Thread-3has put data 1233171571
Thread-7has put data -1796246182
Thread-1has put data -609826403
A from Thread-3has put data 1961867182
A from Thread-1has put data 1961867182
Thread-8has put data 2116621494
A from Thread-8has put data 1961867182
Thread-5has put data -609826403
A from Thread-5has put data 1961867182
A from Thread-7has put data 1961867182
B from Thread-7has put data 1961867182
B from Thread-5has put data 1961867182
Thread-6has put data -609826403
A from Thread-6has put data 1961867182
B from Thread-6has put data 1961867182
Thread-0has put data 1233171571
A from Thread-0has put data 1961867182
B from Thread-0has put data 1961867182
Thread-9has put data 1961867182
A from Thread-9has put data 1961867182
B from Thread-9has put data 1961867182
B from Thread-1has put data 1961867182
Thread-2has put data 1233171571
Thread-4has put data 1233171571
A from Thread-4has put data 1961867182
B from Thread-4has put data 1961867182
B from Thread-8has put data 1961867182
B from Thread-3has put data 1961867182
A from Thread-2has put data 1961867182
B from Thread-2has put data 1961867182

解決方案如下，用線程范圍內的變量，當然這個是比較粗糙的解決方案，代碼如下：

public class ThreadScopeShareData {

    private static int data = 0;
    // 這個用來存放當前線程內的共享數據
    private static Map<Thread, Integer> threadData = new HashMap<Thread, Integer>();

    public static void main(String[] args) {
        for (int i = 0; i < 10; 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() {
            int data = threadData.get(Thread.currentThread());
            System.out.println("A from " + Thread.currentThread().getName() + "has put data " + data);
        }
    }

    static class B {
        public void get() {
            int data = threadData.get(Thread.currentThread());
            System.out.println("B from " + Thread.currentThread().getName() + "has put data " + data);
        }
    }

}

二、JDK中解決線程共享數據（ThreadLocal）

 優化解決方法，更加優雅的代碼，更加人性化的解決方法，使得用戶用起來更加方便，封裝到ThreadLocal中，並且得保證同一個線程，所得到的的是同一份數據！

改造之后的實體對象，代碼如下：

// 改造之后的實體類，封裝創建方法，並且封裝ThreadLocal，來保證同一個線程得到的同一個對象
public class MyThreadScopeData {

    private String name;
    private int age;
    //private static MyThreadScopeData instance = null;
    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;
    }

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

}

測試類中代碼如下：

public class ThreadLocalTest {

    private static ThreadLocal<Integer> x = new ThreadLocal<Integer>();
    private static ThreadLocal<MyThreadScopeData> myThreadLocal = new ThreadLocal<MyThreadScopeData>();

    public static void main(String[] args) {
        // 相當於創建了10個線程
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    int data = new Random().nextInt();
                    System.out.println(Thread.currentThread().getName() + "has put data " + data);
//                    MyThreadScopeData myData = new MyThreadScopeData();
//                    myData.setName("name" + data);
//                    myData.setAge(data);
//                    myThreadLocal.set(myData);

                    MyThreadScopeData.getThreadInstance().setName("name" + data);
                    MyThreadScopeData.getThreadInstance().setAge(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() + "has get data " + data);

//            MyThreadScopeData myData = myThreadLocal.get();
//            System.out.println("A from " + Thread.currentThread().getName() + "has getMyData " + myData.getName() + ","
//                    + myData.getAge());
            
            MyThreadScopeData myData = MyThreadScopeData.getThreadInstance();
            System.out.println("A from " + Thread.currentThread().getName() + "has getMyData " + myData.getName() + ","
                    + myData.getAge());
        }
    }

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

總結：這個線程范圍內的數據共享問題，解決的方法中用到了單例模式中的設計思想，但是區別的地方是加了一步將數據存放到ThreadLocal 中，實現數據的共享！

三、多線程訪問共享數據和線程的方式

 也是線程間數據共享的問題，只不過這個是以實戰的角度來探索線程共享間數據的同步問題，主要學的是這種解決實際問題的能力，看看代碼：

public class MultiThreadShareData {

    public static void main(String[] args) {
        final ShareData1 data1 = new ShareData1();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                data1.decrement();
            }
        }).start();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                data1.increment();
            }
        }).start();
    }

    static class ShareData1 /* implements Runnable */ {

        private int j = 0;
        private int count = 100;

        public synchronized void increment() {
            j++;
        }

        public synchronized void decrement() {
            j--;
        }

        /*
         * @Override public void run() { while (true) { count--; } }
         */
    }

}