（6）多个线程 之间共享数据的方式探讨(设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1 )

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

[java]  view plain copy print ?

1. package com.itm.thread;  
2.   
3. public class MultiThreadShareData {  
4.   
5.       
6.     public static void main(String[] args) {  
7.           
8.         ShareData1 data1 = new ShareData1();  
9.           
10.          //(1)种方法。  
11.         new Thread(data1).start();  
12.           
13.         new Thread(data1).start();  
14.     }  
15.   
16. }  
17.       
18.     class ShareData1 implements Runnable{  
19.               
20.             private int count = 100;  
21.             @Override  
22.             public void run() {  
23.                 while(true){  
24.                 count--;  
25.                 }  
26.             }  
27.           
28.           
29.         private int j = 0;  
30.         public synchronized void increment(){  
31.             j++;  
32.         }  
33.           
34.         public synchronized void descrement(){  
35.             j--;  
36.         }  
37.     }  

如果  每个线程执行的代码不同  怎么解决呢？？？

[java]  view plain copy print ?

1. package com.itm.thread;  
2.   
3. public class MultiThreadShareData2 {  
4.   
5.     private final static TwoShareData data1 = new TwoShareData();  
6.       
7.     public static void main(String[] args) {  
8.           
9.         // 此为  共享数据。  
10.         TwoShareData data2 = new TwoShareData();  
11.           
12.         new Thread(new OneMyRunnable(data2)).start();  
13.         new Thread(new TwoMyRunnable(data2)).start();  
14.           
15.         // 局部变量 加上  final。也可以行得通。  
16.         final TwoShareData data1 = new TwoShareData();  
17.         // Runnable 为 内部类。  
18.         new Thread(new Runnable(){  
19.   
20.             @Override  
21.             public void run() {  
22.                 data1.descrement();  
23.             }  
24.               
25.         }).start();  
26.           
27.         new Thread(new Runnable(){  
28.   
29.             @Override  
30.             public void run() {  
31.                 data1.increment();  
32.             }  
33.               
34.         }).start();  
35.           
36.     }  
37.   
38. }  
39.     class OneMyRunnable implements Runnable{  
40.         private TwoShareData data1;  
41.         public OneMyRunnable(TwoShareData data1){  
42.             this.data1 = data1;  
43.         }  
44.         public void run(){  
45.             data1.descrement();  
46.         }  
47.     }  
48.       
49.     class TwoMyRunnable implements Runnable{  
50.         private TwoShareData data1;  
51.         public TwoMyRunnable(TwoShareData data1){  
52.             this.data1 = data1;  
53.         }  
54.         public void run(){  
55.             data1.increment();  
56.         }  
57.     }  
58.       
59.     class TwoShareData {  
60.               
61.         private int j = 0;  
62.         public synchronized void increment(){  
63.             j++;  
64.         }  
65.           
66.         public synchronized void descrement(){  
67.             j--;  
68.         }  
69.     }  

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

（2）如果每个线程执行的代码不同，这时候需要用不同的Runnable对象，

有如下两种方式来实现这些Runnable对象之间的数据共享：
    1、将共享数据封装在另外一个对象中，然后将这个对象逐一传递给各个Runnable对象。

每个线程对共享数据的操作方法也分配到那个对象身上去完成，这样容易实现针对该数据进行的各个操作的互斥和通信。
    2、将这些Runnable对象作为某一个类中的内部类，共享数据作为这个外部类中的成员变量，

每个线程对共享数据的操作方法也分配给外部类，以便实现对共享数据进行的各个操作的互斥和通信，

作为内部类的各个Runnable对象调用外部类的这些方法。
    3、上面两种方式的组合：将共享数据封装在另外一个对象中，

每个线程对共享数据的操作方法也分配到那个对象身上去完成，

对象作为这个外部类中的成员变量或方法中的局部变量，

每个线程的Runnable对象作为外部类中的成员内部类或局部内部类。
    4、总之，要同步互斥的几段代码最好是分别放在几个独立的方法中，这些方法再放在同一个类中，这样比较容易实现它们之间的同步互斥和通信。

（3）极端且简单的方式，即在任意一个类中定义一个static的变量，这将被所有线程共享。