多线程访问共享数据（1）

多线程访问共享数据解决方案：

一，什么是多线程

 线程是程序中一个单一的顺序控制流程.在单个程序中同时运行多个线程完成不同的工作,称为多线程.

 所有的线程虽然在微观上是串行执行的，但是在宏观上你完全可以认为它们在并行执行

二，多线程访问共享数据解决方案

1，如果每个线程执行的代码相同，可以使用同一个Runnable对象，这个Runnable对象中有那个共享数据。例如：卖票系统。

2，如果每个线程执行的代码不同，这个时候需要用不同的Runnable对象，有如下三种方式来实现这些Runnable对象之间的数据共享：

  将共享数据封装在另外一个对象中，然后将这个对象逐一传递给各个Runnable对象。每个线程对共享数据的操作方法也分配到那个对象身上去完成，这样容易实现针对该数据进行的各个操作的互斥和通信。

  将这些Runnable对象作为某一个类中的内部类，共享数据作为这个外部类中的成员变量，每个线程对共享数据的操作方法也分配给外部类，以便实现对共享数据进行的各种操作的互斥和通信，作为内部类的各个Runable对象调用外部类的这些方法。

    上面两种方式的组合：将共享数据封装在另外一个对象中，每个线程对共享数据的操作方法也分配到那个对象身上去完成，对象作为这个外部类中的成员变量或方法中的局部变量，每个线程的Runnable对象作为外部类中的成员内部类或局部内部类。

  总之，要同步互斥的几段代码最好是分别放在几个独立的方法中这些方法再放在同一个类中，这样比较容易实现他们之间的同步互斥和通信。

 

一个外部类A中有两个内部类，这两个内部类B、C如何共享数据？

——B、C都操作外部类A的同一个成员变量。所以，两个Runnable对象要共享同一份数据，可以把两个Runnable作为外部类的内部类，把共享数据作为外部类的成员变量。

三，例子：

1，如果每个线程执行的代码相同，可以使用同一个Runnable对象，这个Runnable对象中有那个共享数据。例如：卖票系统。

代码解释：开启三个线程，同时访问共享数据count，均对其进行--操作。实现思路：由于三个线程执行的代码相同(对共享数据的操作相同)，所以使用同一个Runnable（如下代码：类ShareData1实现Runnable接口），该Runnable对象中封装了共享数据count，即对共享数据count的操作。

[java] view plain copy

1. package com.tgb.thread07;  
2.   
3.     /** 
4.      * 多线程访问共享对象和数据之——模拟卖票系统 
5.      * 方案：由于买票时每个线程执行的代码相同（均是在现有票数上--），因此 可以使用同一个Runnable对象， 
6.      *     这个Runnable对象中有那个共享数据。例如：卖票系统。 
7.      *  
8.      * @author hanxuemin 
9.      * @date 2015年7月30日10:06:35 
10.      * 
11.      */  
12.     public class MultiThreadShareData {  
13.       
14.         public static void main(String[] args) {  
15.       
16.             ShareData1 data1 = new ShareData1();  
17.             /** 
18.              * 开启三个线程，卖票，访问共享数据 
19.              */  
20.             new Thread(data1).start();  
21.             new Thread(data1).start();  
22.             new Thread(data1).start();  
23.         }  
24.     }  
25.       
26.     /** 
27.      * 包含共享数据的Runnable实现类ShareData1 
28.      *  
29.      * @author hanxuemin 
30.      *  
31.      */  
32.     class ShareData1 implements Runnable {  
33.       
34.         private int count = 100; // 票数总共100张（共享数据）  
35.       
36.         public void run() {  
37.             while (count > 0) {  
38.                 count--; // 票数-1  
39.                 System.out.println(Thread.currentThread().getName() + "买票后，票总数为：" + count);  
40.             }  
41.         }  
42.       
43.     }  

2，如果每个线程执行的代码不同，这个时候需要用不同的Runnable对象，有如下三种方式来实现这些Runnable对象之间的数据共享：

   方式一：将共享数据封装在另外一个对象中，然后将这个对象逐一传递给各个Runnable对象。每个线程对共享数据的操作方法也分配到那个对象身上去完成，这样容易实现针对该数据进行的各个操作的互斥和通信。

Demo：设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。

代码解释：(1)共享数据为j，两个线程对其++，两个线程对其--，因此执行的代码不同，因此需要不同的Runnable对象;(2)看题得知4个线程对共享数据共两种操作，所以创建两个不同的Runnable实现类——MyRunnable1、MyRunnable2；(3)在创建类ShareData2，将共享数据封装在该类中，同时封装了每个线程对共享数据的操作方法；(4)将ShareData2对象逐一传递给每个Runnable对象。

[java] view plain copy

1. package com.tgb.thread07;  
2.   
3. /** 
4.  * 多线程访问共享对象和数据之——每个线程执行的代码不同 
5.  *  
6.  * 方案：如果每个线程执行的代码不同，这个时候需要用不同的Runnable对象， 有如下三种方式来实现这些Runnable对象之间的数据共享： 
7.  * 方案一：将共享数据封装在另外一个对象中，然后将这个对象逐一传递给各个Runnable对象。 
8.  * 每个线程对共享数据的操作方法也分配到那个对象身上去完成，这样容易实现针对该数据进行的各个操作的互斥和通信。 
9.  *  
10.  * 该程序实现Demo：设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。 
11.  * 分析：(1)对共享数据分别有两个操作：<a>对共享数据j进行++；<b>对共享数据j进行--; ——所以 
12.  * 需要创建两个Runnable对象（分别对j进行++ 和 --） 
13.  *  
14.  * @author hanxuemin 
15.  * @date 2015年7月30日10:06:35 
16.  * 
17.  */  
18. public class MultiThreadShareData02 {  
19.   
20.     public static void main(String[] args) {  
21.   
22.         final ShareData2 data2 = new ShareData2();// 创建ShareData2实例对象（该对象中封装了共享数据，和每个线程对共享数据的操作方法）  
23.         for (int i = 0; i < 2; i++) {  
24.             /** 
25.              * 创建两个Runnable对象，将封装了共享数据的data2对象逐一传递给这两个Runnable对象 
26.              */  
27.             MyRunnable1 myRunnable1 = new MyRunnable1(data2);  
28.             MyRunnable2 myRunnable2 = new MyRunnable2(data2);  
29.             /** 
30.              * 启动两个线程，这两个线程使用两个不同的Runnable 
31.              */  
32.             new Thread(myRunnable1).start();  
33.             new Thread(myRunnable2).start();  
34.         }  
35.     }  
36. }  
37.   
38. /** 
39.  * MyRunnable1实现Runnable接口 
40.  *  
41.  * @author hanxuemin 
42.  * 
43.  */  
44. class MyRunnable1 implements Runnable {  
45.     private ShareData2 data2;  
46.   
47.     public MyRunnable1(ShareData2 data2) {  
48.         this.data2 = data2;  
49.     }  
50.   
51.     @Override  
52.     public void run() {  
53.         data2.increment(); // 调用++方法  
54.     }  
55.   
56. }  
57.   
58. /** 
59.  * MyRunnable2类实现Runnable接口 
60.  *  
61.  * @author hanxuemin 
62.  * 
63.  */  
64. class MyRunnable2 implements Runnable {  
65.   
66.     private ShareData2 data2;  
67.   
68.     public MyRunnable2(ShareData2 data2) {  
69.         this.data2 = data2;  
70.     }  
71.   
72.     @Override  
73.     public void run() {  
74.         data2.decrement(); // 调用--方法  
75.   
76.     }  
77. }  
78.   
79. /** 
80.  * 封装了共享数据的类ShareData2。同时，该类封装了每个线程对共享数据的操作方法 
81.  *  
82.  * @author hanxuemin 
83.  *  
84.  */  
85. class ShareData2 {  
86.   
87.     private int j = 100; // 共享数据j  
88.   
89.     /** 
90.      * 对j进行++的方法 
91.      */  
92.     public synchronized void increment() {  
93.         j++;  
94.         System.out.println("++方法：" + Thread.currentThread().getName()  
95.                 + "操作共享数据后，当前共享数据的值为" + j);  
96.     }  
97.   
98.     /** 
99.      * 对j进行--的方法 
100.      */  
101.     public synchronized void decrement() {  
102.         j--;  
103.         System.out.println("--方法" + Thread.currentThread().getName()  
104.                 + "操作共享数据后，当前共享数据的值为" + j);  
105.     }  
106. }  

四，总结

不同是情况使用不同的解决方案。
另外两种方式，见下一篇博客