java线程深度解析（二）——线程互斥技术与线程间通信

http://blog.csdn.net/daybreak1209/article/details/51307679

     在java多线程——线程同步问题中，对于多线程下程序启动时出现的线程安全问题的背景和初步解决方案已经有了详细的介绍。本文将再度深入解析对线程代码块和方法的同步控制和多线程间通信的实例。

一、再现多线程下安全问题

先看开启两条线程，分别按序打印字符串的实验

1、创建一个Output内部类，并给出根据参数name，循环打印出传入字符串

2、new 两个线程，分别传入zhongailing、max两个name，调用同一个output对象的output方法

[html] view plain copy

 

1.     public static void main(String[] args) throws InterruptedException {  
2.                 Output output=new Output();    
3.         new Thread(new Runnable(){   
4.              @Override  
5.             public void run() {  
6.                  while(true)  
7.                  {  
8.                      try {  
9.                         Thread.sleep(1000);//休息1s  
10.                     } catch (InterruptedException e) {  
11.                         e.printStackTrace();  
12.                     }  
13.                      output.output("zhongailing");  
14.                  }  
15.                   
16.             }  
17.          }).start();  
18.           
19.         new Thread(new Runnable(){  
20.              @Override  
21.             public void run() {  
22.                  while(true)  
23.                  {  
24.                      try {  
25.                         Thread.sleep(1000);//休息1s  
26.                     } catch (InterruptedException e) {  
27.                         e.printStackTrace();  
28.                     }  
29.                      output.output("max");  
30.                  }  
31.                   
32.             }  
33.          }).start();  
34.     }  
35. //内部类  
36. class Output  
37.     {  
38.         public void output(String name)  
39.         {  
40.             for(int i=0;i<name.length();i++)  
41.             synchronized (name)  
42.             {  
43.                 System.out.print(name.charAt(i));  
44.             }  
45.             System.out.println();  
46.         }  
47.     }  

摘取部分输入结果如下：

[html] view plain copy

 

1. zhonmaxgailing  
2. max  
3. zhongailing  
4. zhongailing  
5. max  
6. mazhongax  
7. iling  
8. max  
9. zhongailing  
10. zhonmgax  
11. ailing  
12. mzhax  
13. ongailing  
14. zmhaoxngailing  
15. max  
16. zhongailing  

     可以看出，打印出来的name名除了zhongailing 和max之外，还出现iling、mzhax之类字样，这是肿么回事？

     这是因为两条线程同时调用同一个output对象的output方法，当第一个线程的打印循环还未走完时，下一个线程又进入传入另一个参数继续循环，使得打印出的结果出现iling、mzhax这些非正常字样。

二、解决线程安全问题——设置线程互斥
     在java多线程——线程同步问题中已经介绍了使用synchronized关键字对代码块或者整个方法体进行设置，使得该段代码享有排他性，独立占用资源，完成打印循环之后，下个线程再进入。

[html] view plain copy

 

1. class Output  
2. {  
3.     public void output(String name)  
4.     {  
5.         for(int i=0;i<name.length();i++)  
6.         synchronized (this)   //代码块同步，指定加锁对象为this，指向当前传入的output  
7.         {  
8.             System.out.print(name.charAt(i));  
9.         }  
10.         System.out.println();  
11.     }  
12.       
13.     public synchronized void output2(String name) //在方法体上执行synchronized，把整个方法都保护起来。  
14.     {  
15.         for(int i=0;i<name.length();i++)  
16.         {  
17.             System.out.print(name.charAt(i));  
18.         }  
19.         System.out.println();  
20.     }  

     题外话：客户端使用main方法进行调用时：

[html] view plain copy

 

1. public static void main(String[] args) throws InterruptedException {  
2.         Output output=new Output();    
3.         new Thread(new Runnable(){  
4.              @Override  
5.             public void run() {  
6.                  while(true)  
7.                  {  
8.                      try {  
9.                         Thread.sleep(1000);//休息1s  
10.                     } catch (InterruptedException e) {  
11.                         e.printStackTrace();  
12.                     }  
13.                      output.output("zhongailing");//内部类不能访问局部变量？？  
14.                  }  
15.                   
16.             }  
17.          }).start();  
18.     }  

      在new 内部类 Output是报错，这是因为在静态方法中不能实例化内部类。因为内部类的特点就是可以访问外部类的成员变量，又因为对象创建完了才为成员变量分配空间，所以在使用变量之前，这个类已经实例化了。而静态方法执行时，可以不用创建这个对象就使用而矛盾。并且main这个静态方法在运行时没有使用任何外部类的成员变量，所以要创建内部类的实例对象，必须已经存在外部类的实例对象来创建。代码改造为：

[html] view plain copy

 

1. public static void main(String[] args) throws InterruptedException {  
2.     new SynchronizationApp().init();  
3. }  
4.   
5. public void init()//初始化-调用这个非静态方法时，一定是某个类已经被实例化了，该方法才能被调用。  
6. {  
7.     Output output=new Output();    
8.     new Thread(new Runnable(){//线程0  
9.          @Override  
10.         public void run() {  
11.              while(true)  
12.              {  
13.                  try {  
14.                     Thread.sleep(1000);//休息1s  
15.                 } catch (InterruptedException e) {  
16.                     e.printStackTrace();  
17.                 }  
18.                  output.output("zhongailing");  
19.              }  
20.               
21.         }  
22.      }).start();  
23.       
24.     new Thread(new Runnable(){//线程1  
25.          @Override  
26.         public void run() {  
27.              while(true)  
28.              {  
29.                  try {  
30.                     Thread.sleep(1000);//休息1s  
31.                 } catch (InterruptedException e) {  
32.                     e.printStackTrace();  
33.                 }  
34.                  output.output("max");  
35.              }            
36.         }  
37.      }).start();  
38. }  
39. //内部类，用于循环字母，挨个输出传入的name字符。  
40. class Output  
41. {  
42.     public void output(String name)  
43.     {  
44.         for(int i=0;i<name.length();i++)  
45.         synchronized (this)    //或者在方法上加同步关键字  
46.         {  
47.             System.out.print(name.charAt(i));  
48.         }  
49.         System.out.println();  
50.     }  
51. }}  

使用synchronized需谨慎：

1、对于多个线程的执行对象一定是同一个。例如这里new 同一个Output对象，执行方法，只是方法传入的参数不同。这个应该比较好理解，如果你为当前线程加上互斥方案，但多个线程启用的并不是同一个对象，那无论做多少不同步方案都是无用功，因为压根就没在一个对象中进行多线程处理。

2、该关键字在一段代码里一般只使用一次。打个比方，如果将方法和方法内部的代码块同时加上synchronized关键字，就类似于原本只有一把锁，钥匙给了方法，而代码块也需要这把钥匙开锁执行自己的代码，双方谁也不释放，容易产生死锁问题。

三、多线程间通信

一个实例：两条线程-主线程、子线程，要求子线程先执行10次，主线程再执行100次，整体反复执行50次。

代码思路：

1、首先两条线程互斥，各不影响

2、创建标识，让子线程先执行，主线程等待；当子线程执行完第一个10次循环，改变标识，唤醒主线程执行。

[html] view plain copy

 

1. package it.synchronization;  
2.   
3. public class ThreadCommunication {   
4.     public static void main(String[] args) {  
5.         new ThreadCommunication().init();   
6.     }  
7.     public void init()  
8.     {  
9.         innerBusiness inner=new innerBusiness();  
10.         new Thread(new Runnable(){   //线程1  
11.             @Override  
12.             public void run() {  
13.                 for(int i=1;i<=50;i++) //再循环50次  
14.                 {  
15.                     try {  
16.                         inner.sub(i);  
17.                     } catch (InterruptedException e) {  
18.                         // TODO Auto-generated catch block  
19.                         e.printStackTrace();  
20.                     }  
21.                 }                             
22.             }             
23.         }).start();  
24.           
25.           
26.         new Thread(new Runnable(){//线程2  
27.             @Override  
28.             public void run() {  
29.                 for(int i=1;i<=50;i++)  
30.                 {  
31.                 /*synchronized (ThreadCommunication.class) {//多组线程呢，这个范围有点太大。如果该类中有多个线程组，这种方式就会出问题。           
32.                 }*/  
33.                     try {  
34.                         inner.main(i);  
35.                     } catch (InterruptedException e) {  
36.                         // TODO Auto-generated catch block  
37.                         e.printStackTrace();  
38.                     }     
39.                 }  
40.   
41.             }  
42.         }).start();  
43.     }  
44.     class innerBusiness //创建内部类  
45.     {  
46.         private boolean bShouldSub=true;//约定sub线程先执行  
47.         public synchronized void  sub(int i) throws InterruptedException  
48.         {  
49.             if(!bShouldSub)//如果没到子线程执行，子线程wait  
50.             {  
51.                 this.wait();  
52.             }  
53.             for(int j=1;j<=10;j++)  
54.             {  
55.                 System.out.println("子线程运行第"+j+"次");  
56.             }  
57.             bShouldSub=false;  
58.             this.notify();//唤醒等待线程-main  
59.         }  
60.           
61.         public synchronized void main(int i) throws InterruptedException  
62.         {  
63.             if(bShouldSub)//如果该子线程执行，主线程wait  
64.             {  
65.                 this.wait();  
66.             }  
67.             for(int j=0;j<100;j++)  
68.             {  
69.                 System.out.println("主线程运行第"+j+"次");  
70.             }  
71.             bShouldSub=true;  
72.             this.notify();//唤醒等待线程-sub  
73.         }  
74.     }  
75. }  

亮点：

           将互斥约束到线程资源上，而非线程代码块中：将两条线程代码写到一个innerclass中，在方法上进行同步约束和线程执行等待逻辑操作，而不是直接在main方法new Thread时，对代码块进行互斥。这样无论谁调用线程逻辑，直接调用innerclass（资源的）的sub 和main方法就可满足线程安全要求，更符合面向对象的思想。同时免去了对同对象参数的考虑。

四、总结

一）synchronized是Java语言级别内置的同步机制，根据作用的对象分为：类锁、实例锁；

对于类锁的应用：只能应用到类的静态方法上，形如：staticsynchronized method();

对于实例锁应用：

1、非静态方法：synchronized method();

2、代码块：synchronized{}或synchronized(this){}

3、指定实例：synchronized(Object obj);

      非静态方法和代码块使用synchronized的实质都一样，对当前所属类的实例枷锁。而指定实例是对括号里传入的obj对象加锁。如同上面的例子，使用的就是代码块和指定实例对象加锁方式。另外synchronized不能被直接继承。

      笔者体会而言， 对于多线程中synchronized的使用，除了它的作用范围定在类上、方法上、对象、代码块这些point之外，还需要注意加锁的对象是否是同一个。例如上面例子如果不加this，哪怕使用了synchronized对于线程安全还是无法保障的。因为线程调用同一对象的output方法，琐是加了，but并未作用于该对象上。

二）多线程间通信wait，notify方法的合理使用，也是线程的重要部分。本文仅提供了一个线程间通信的实例，在接下来的博文将详细介绍线程间通信应用。