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

}