java基础——多线程（线程的同步互斥与通信）

一、 线程的同步互斥的图文解说

二、多个线程访问共享对象和数据的方式

1、如果每个线程执行的代码相同，可以使用同一个Runnable对象，这个Runnable对象中有那个共享数据，例如，买票系统就可以这么做。
2、如果每个线程执行的代码不同，这时候需要用不同的Runnable对象，有如下两种方式来实现这些Runnable对象之间的数据共享：
1）将共享数据封装在另外一个对象中，然后将这个对象逐一传递给各个Runnable对象。每个线程对共享数据的操作方法也分配到那个对象身上去完成，这样容易实现针对该数据进行的各个操作的互斥和通信。
2）将这些Runnable对象作为某一个类中的内部类，共享数据作为这个外部类中的成员变量，每个线程对共享数据的操作方法也分配给外部类，以便实现对共享数据进行的各个操作的互斥和通信，作为内部类的各个Runnable对象调用外部类的这些方法。
3）上面两种方式的组合：将共享数据封装在另外一个对象中，每个线程对共享数据的操作方法也分配到那个对象身上去完成，对象作为这个外部类中的成员变量或方法中的局部变量，每个线程的Runnable对象作为外部类中的成员内部类或局部内部类。（如下例子所示）

例子（面试题）：子线程循环10次，接着主线程循环100，接着又回到子线程循环10次，接着再回到主线程又循环100，如此循环50次，请写出程序。

[java]  view plain copy

1. public class traditionalThreadCommunication {  
2.     public static void main(String[] args) {  
3.         final Bussness busness = new Bussness();  
4.         new Thread(new Runnable() {  
5.             @Override  
6.             public void run() {  
7.                 for (int i = 1; i <= 50; i++) {  
8.                     busness.sub(i);  
9.                 }  
10.             }  
11.         }).start();  
12.   
13.         for (int i = 1; i <= 50; i++) {  
14.             busness.main(i);  
15.         }  
16.     }  
17.   
18. }  
19. /** 
20.  * Bussness 
21.  * 同组共享数据封装在这个对象里面 
22.  * @author Administrator 
23.  */  
24. class Bussness {  
25.     private boolean bshouldSub = true; //这个标志使子线程和主线程和谐  
26.     /*sub方法：子线程对共享数据的操作方法也也在Bussness类上实现*/  
27.     public synchronized void sub(int i) { //在这里实现同步  
28.         <span style="font-family:Arial,Helvetica,sans-serif">while</span><span style="font-family:Arial,Helvetica,sans-serif"> (!bshouldSub) {</span>  
29.             try {  
30.                 this.wait();//会产生异常  
31.             } catch (InterruptedException e) {  
32.                 e.printStackTrace();  
33.             }  
34.         }  
35.             for (int j = 1; j <= 10; j++) {  
36.                 System.out.println("sub thread sequece of :" + j+ "   loop of:" + i);  
37.         }  
38.             bshouldSub = false;//子线程执行完一次，换主线程执行  
39.             this.notify();//唤醒正在等待的线程  
40.     }  
41.   
42.     /*main方法：主线程对共享数据的操作方法也在Bussness类上实现*/  
43.     public synchronized void main(int i) {        
44.         while(bshouldSub){  
45.             try {  
46.                 this.wait();//会产生异常  
47.             } catch (InterruptedException e) {  
48.                 e.printStackTrace();  
49.             }  
50.         }  
51.         for (int j = 1; j <= 100; j++) {  
52.             System.out.println("main thread sequece of :" + j + "   loop of:"+ i);  
53.         }  
54.         bshouldSub = true;  
55.         this.notify();  
56.     }  
57.   
58. }  

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

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

二、ThreadLocal实现线程范围的共享变量

1、ThreadLocal类的定义：见上图示意图和辅助代码解释ThreadLocal的作用和目的：用于实现线程内的数据共享，即对于相同的程序代码，多个模块在同一个线程中运行时要共享一份数据，而在另外线程中运行时又共享另外一份数据。

2、每个线程调用全局ThreadLocal对象的set方法，就相当于往其内部的map中增加一条记录，key分别是各自的线程，value是各自的set方法传进去的值。在线程结束时可以调用ThreadLocal.clear()方法，这样会更快释放内存，不调用也可以，因为线程结束后也可以自动释放相关的ThreadLocal变量。

3、ThreadLocal的应用场景：
1)订单处理包含一系列操作：减少库存量、增加一条流水台账、修改总账，这几个操作要在同一个事务中完成，通常也即同一个线程中进行处理，如果累加公司应收款的操作失败了，则应该把前面的操作回滚，否则，提交所有操作，这要求这些操作使用相同的数据库连接对象，而这些操作的代码分别位于不同的模块类中。

2)银行转账包含一系列操作： 把转出帐户的余额减少，把转入帐户的余额增加，这两个操作要在同一个事务中完成，它们必须使用相同的数据库连接对象，转入和转出操作的代码分别是两个不同的帐户对象的方法。

3)例如Strut2的ActionContext，同一段代码被不同的线程调用运行时，该代码操作的数据是每个线程各自的状态和数据，对于不同的线程来说，getContext方法拿到的对象都不相同，对同一个线程来说，不管调用getContext方法多少次和在哪个模块中getContext方法，拿到的都是同一个

4、实验案例：定义一个全局共享的ThreadLocal变量，然后启动多个线程向该ThreadLocal变量中存储一个随机值，接着各个线程调用另外其他多个类的方法，这多个类的方法中读取这个ThreadLocal变量的值，就可以看到多个类在同一个线程中共享同一份数据。实现对ThreadLocal变量的封装，让外界不要直接操作ThreadLocal变量。

[java]  view plain copy

1. package my.coco.thread;  
2.   
3. import java.util.Random;  
4.   
5. public class ThreadLoacalTest {  
6.   
7.     public static void main(String[] args) {  
8.         final A a = new A();  
9.         final B b = new B();  
10.         for(int i=0;i<5;i++){  
11.             new Thread(){  
12.                 public void run(){  
13.                     /*1. MyThreadLocalData.x.set(new Random().nextInt(10000)); 
14.                     System.out.println(Thread.currentThread() + "has put " +  MyThreadLocalData.x.get()); 
15.                     a.say(); 
16.                     b.sayHello();*/  
17.                       
18.                     /*2. MyThreadLocalData.set(new Random().nextInt(10000));                     
19.                     System.out.println(Thread.currentThread() + "has put " +  MyThreadLocalData.get());                  
20.                     a.say(); 
21.                     b.sayHello();*/  
22.                       
23.                     MyThreadLocalData.getMyData().setX(new Random().nextInt(10000));  
24.                     System.out.println(Thread.currentThread() + "has put " +  MyThreadLocalData.getMyData().getX());  
25.                     a.say();  
26.                     b.sayHello();     
27.                     MyThreadLocalData.clear();  
28.                 }  
29.             }.start();  
30.         }  
31.     }  
32. }  
33.   
34. /* 
35.  * MyThreadLocalData 
36.  * 实现对ThreadLocal变量的封装，让外界不要直接操作ThreadLocal变量。 
37.  */  
38. class MyThreadLocalData{  
39.     //1. public static ThreadLocal x = new ThreadLocal();  
40.     /*2. private static ThreadLocal x = new ThreadLocal(); 
41.     public static void set(Object val){ 
42.         x.set(val); 
43.     } 
44.     public static Object get(){ 
45.         return x.get(); 
46.     }*/  
47.       
48.     /*无参构造函数*/  
49.     private MyThreadLocalData(){}  
50.     //实例化ThreadLocal  
51.     private static ThreadLocal instanceContainer = new ThreadLocal();  
52.     //单例模式 获取MyThreadLocalData的实例对象  
53.     public static MyThreadLocalData getMyData(){  
54.         MyThreadLocalData instance = (MyThreadLocalData)instanceContainer.get();  
55.         if(instance == null){  
56.             instance = new MyThreadLocalData();  
57.             instanceContainer.set(instance);  
58.         }  
59.         return instance;  
60.     }  
61.       
62.     public static void clear(){  
63.         instanceContainer.remove();  
64.     }  
65.       
66.     private Integer x;  
67.     public void setX(Integer x){  
68.         this.x = x;  
69.     }  
70.     public Integer getX(){  
71.         return x;  
72.     }  
73. }  
74.   
75. class A{  
76.     public void say(){  
77.         //1. System.out.println(Thread.currentThread() + ": A has getted " +  MyThreadLocalData.x.get());  
78.         //2. System.out.println(Thread.currentThread() + ": A has getted " +  MyThreadLocalData.get());   
79.         System.out.println(Thread.currentThread() + ": A has getted " +  MyThreadLocalData.getMyData().getX());           
80.     }  
81. }  
82.   
83. class B{  
84.     public void sayHello(){  
85.         //1. System.out.println(Thread.currentThread() + ": B has getted " +  MyThreadLocalData.x.get());  
86.         //2. System.out.println(Thread.currentThread() + ": B has getted " +  MyThreadLocalData.get());       
87.         System.out.println(Thread.currentThread() + ": B has getted " +  MyThreadLocalData.getMyData().getX());           
88.           
89.     }     
90. }