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

 }