Java多线程编程--（3）线程互斥、同步的理解

from  http://blog.csdn.net/drifterj/article/details/7771230

多线程并行编程中，线程间同步与互斥是一个很有技巧的也很容易出错的地方。

线程间互斥应对的是这种场景：多个线程操作同一个资源（即某个对象），为保证线程在对资源的状态（即对象的成员变量）进行一些非原子性操作后，状态仍然是正确的。典型的例子是“售票厅售票应用”。售票厅剩余100张票，10个窗口去卖这些票。这10个窗口，就是10条线程，售票厅就是他们共同操作的资源，其中剩余的100张票就是这个资源的一个状态。线程买票的过程就是去递减这个剩余数量的过程。不进行互斥控制的代码如下：

[java] view plain copy

1. package cn.test;  
2.   
3. public class TicketOffice {  
4.       
5.     private int ticketNum = 0;  
6.   
7.     public TicketOffice(int ticketNum) {  
8.         super();  
9.         this.ticketNum = ticketNum;  
10.     }  
11.       
12.     public int getTicketNum() {  
13.         return ticketNum;  
14.     }  
15.   
16.     public void setTicketNum(int ticketNum) {  
17.         this.ticketNum = ticketNum;  
18.     }  
19.       
20.     /** 
21.      *  售票厅卖票的方法，这个方法操作了售票厅对象唯一的状态--剩余火车票数量。 
22.      *  该方法此处并未进行互斥控制。 
23.      */  
24.     public void sellOneTicket(){  
25.           
26.         ticketNum--;  
27.         // 打印剩余票的数量  
28.         if(ticketNum >= 0){  
29.               
30.             System.out.println("售票成功，剩余票数： " + ticketNum);  
31.         }else{  
32.               
33.             System.out.println("售票失败，票已售罄！");  
34.         }  
35.           
36.     }  
37.       
38.     public static void main(String[] args) {  
39.           
40.         final TicketOffice ticketOffice = new TicketOffice(100);  
41.           
42.         // 启动10个线程，即10个窗口开始卖票  
43.         for(int i=0;i<10;i++){  
44.               
45.             new Thread(new Runnable(){  
46.   
47.                 @Override  
48.                 public void run() {  
49.                       
50.                     // 当还有剩余票的时候，就去执行  
51.                     while(ticketOffice.getTicketNum() > 0){  
52.                           
53.                         ticketOffice.sellOneTicket();  
54.                     }  
55.                       
56.                 }  
57.                   
58.             }).start();  
59.         }  
60.     }  
61.   
62. }  

最后打印的部分结果如下：

[plain] view plain copy

1. 售票成功，剩余票数： 93  
2. 售票成功，剩余票数： 92  
3. 售票成功，剩余票数： 91  
4. 售票成功，剩余票数： 95  
5. 售票成功，剩余票数： 96  
6. 售票成功，剩余票数： 87  
7. 售票成功，剩余票数： 86  
8. 售票成功，剩余票数： 88  
9. 售票成功，剩余票数： 89  
10. 售票成功，剩余票数： 83  
11. 售票成功，剩余票数： 82  
12. 售票成功，剩余票数： 81  
13. 售票成功，剩余票数： 90  
14. 售票成功，剩余票数： 79  
15. 售票成功，剩余票数： 93  

 

可以看到售票厅资源的状态：剩余票的数量，是不正确的。数量忽大忽小，这就是对统一资源进行操作没有控制互斥的结果。
互斥操作的控制，Java提供了关键字synchronized进行的。synchronized可以修饰方法，也可以修饰代码段。其代表的含义就是：进入他修饰的这段代码内的线程必须先去获取一个特定对象的锁定标示，并且虚拟机保证这个标示一次只能被一条线程拥有。通过这两种方式修改上述代码的方法sellOneTicket()，如下：

[java] view plain copy

1. /** 
2.      *  已经进行了互斥控制。这里是通过synchronized修饰整个方法实现的。 
3.      *  线程想进入这个方法，必须获取当前对象的锁定表示！ 
4.      */  
5.     public synchronized void sellOneTicket(){  
6.           
7.         ticketNum--;  
8.         // 打印剩余票的数量  
9.         if(ticketNum >= 0){  
10.               
11.             System.out.println("售票成功，剩余票数： " + ticketNum);  
12.         }else{  
13.               
14.             System.out.println("售票失败，票已售罄！");  
15.         }  
16.           
17.     }  
18.       
19.     /** 
20.      *  已经进行了互斥控制。这里是通过synchronized修饰代码块实现的。线程要想进入修饰的代码块， 
21.      *  必须获取lock对象的对象标示。 
22.      */  
23.     private Object lock = new Object();  //确保整个过程中lock对象不能被改变
    
24.     public void sellOneTicket2(){  
25.           
26.         synchronized(lock){  
27.               
28.             ticketNum--;  
29.             // 打印剩余票的数量  
30.             if(ticketNum >= 0){  
31.                   
32.                 System.out.println("售票成功，剩余票数： " + ticketNum);  
33.             }else{  
34.                   
35.                 System.out.println("售票失败，票已售罄！");  
36.             }  
37.         }  
38.           
39.     }  

通过互斥控制后的输出为：非常整齐，不会出现任何状态不对的情况。

[java] view plain copy

1. 售票成功，剩余票数： 99  
2. 售票成功，剩余票数： 98  
3. 售票成功，剩余票数： 97  
4. 售票成功，剩余票数： 96  
5. 售票成功，剩余票数： 95  
6. 售票成功，剩余票数： 94  
7. 售票成功，剩余票数： 93  
8. 售票成功，剩余票数： 92  
9. 售票成功，剩余票数： 91  
10. 售票成功，剩余票数： 90  
11. 售票成功，剩余票数： 89  
12. 售票成功，剩余票数： 88  
13. 售票成功，剩余票数： 87  
14. 售票成功，剩余票数： 86  
15. 售票成功，剩余票数： 85  
16. 售票成功，剩余票数： 84  
17. 售票成功，剩余票数： 83  
18. 售票成功，剩余票数： 82  

 

同步的概念再于线程间通信，比较典型的例子就是“生产者-消费者问题”。

多个生产者和多个消费者就是多条执行线程，他们共同操作一个数据结构中的数据，数据结构中有时是没有数据的，这个时候消费者应该处于等待状态而不是不断的去访问这个数据结构。这里就涉及到线程间通信（当然此处还涉及到互斥，这里暂不考虑这一点），消费者线程一次消费后发现数据结构空了，就应该处于等待状态，生产者生产数据后，就去唤醒消费者线程开始消费。生产者线程某次生产后发现数据结构已经满了，也应该处于等待状态，消费者消费一条数据后，就去唤醒生产者继续生产。

实现这种线程间同步，可以通过Object类提供的wait，notify， notifyAll 3个方法去进行即可。一个简单的生产者和消费者的例子代码为：

[java] view plain copy

1. package cn.test;  
2.   
3. public class ProducerConsumer {  
4.       
5.     public static void main(String[] args) {  
6.           
7.         final MessageQueue mq = new MessageQueue(10);  
8.         // 创建3个生产者  
9.         for(int p=0;p<3;p++){  
10.               
11.             new Thread(new Runnable(){  
12.   
13.                 @Override  
14.                 public void run() {  
15.                       
16.                     while(true){  
17.                           
18.                         mq.put("消息来了！");  
19.                         // 生产消息后，休息100毫秒  
20.                         try {  
21.                             Thread.currentThread().sleep(100);  
22.                         } catch (InterruptedException e) {  
23.                             e.printStackTrace();  
24.                         }  
25.                     }  
26.                 }  
27.                   
28.                   
29.             }, "Producer" + p).start();  
30.         }  
31.           
32.         // 创建3个消费者  
33.         for(int s=0;s<3;s++){  
34.               
35.             new Thread(new Runnable(){  
36.   
37.                 @Override  
38.                 public void run() {  
39.                       
40.                     while(true){  
41.                           
42.                         mq.get();  
43.                         // 消费消息后，休息100毫秒  
44.                         try {  
45.                             Thread.currentThread().sleep(100);  
46.                         } catch (InterruptedException e) {  
47.                             e.printStackTrace();  
48.                         }  
49.                     }  
50.                 }  
51.                   
52.                   
53.             }, "Consumer" + s).start();  
54.         }  
55.     }  
56.       
57.     /** 
58.      * 内部类模拟一个消息队列，生产者和消费者就去操作这个消息队列 
59.      */  
60.     private static class MessageQueue{  
61.           
62.         private String[] messages;// 放置消息的数据结构  
63.         private int opIndex; // 将要操作的位置索引  
64.   
65.         public MessageQueue(int size) {  
66.               
67.             if(size <= 0){  
68.                   
69.                 throw new IllegalArgumentException("消息队列的长度至少为1！");  
70.             }  
71.             messages = new String[size];  
72.             opIndex = 0;  
73.         }  
74.           
75.         public synchronized void put(String message){  
76.               
77.             // Java中存在线程假醒的情况，此处用while而不是用if！可以参考Java规范！  
78.             while(opIndex == messages.length){  
79.                   
80.                 // 消息队列已满，生产者需要等待  
81.                 try {  
82.                     wait();  
83.                 } catch (InterruptedException e) {  
84.                     e.printStackTrace();  
85.                 }  
86.             }  
87.             messages[opIndex] = message;  
88.             opIndex++;  
89.             System.out.println("生产者 " + Thread.currentThread().getName() + " 生产了一条消息: " + message);  
90.             // 生产后，对消费者进行唤醒  
91.             notifyAll();  
92.         }  
93.           
94.         public synchronized String get(){  
95.               
96.             // Java中存在线程假醒的情况，此处用while而不是用if！可以参考Java规范！  
97.             while(opIndex == 0){  
98.                   
99.                 // 消息队列无消息，消费者需要等待  
100.                 try {  
101.                     wait();  
102.                 } catch (InterruptedException e) {  
103.                     e.printStackTrace();  
104.                 }  
105.             }  
106.             String message = messages[opIndex-1];  
107.             opIndex--;  
108.             System.out.println("消费者 " + Thread.currentThread().getName() + " 消费了一条消息: " + message);  
109.             // 消费后，对生产者进行唤醒  
110.             notifyAll();  
111.             return message;  
112.         }  
113.           
114.     }  
115.   
116. }  

一次输出为：

[java] view plain copy

1. 消费者 Consumer1 消费了一条消息: 消息来了！  
2. 生产者 Producer0 生产了一条消息: 消息来了！  
3. 消费者 Consumer0 消费了一条消息: 消息来了！  
4. 生产者 Producer2 生产了一条消息: 消息来了！  
5. 消费者 Consumer2 消费了一条消息: 消息来了！  
6. 生产者 Producer1 生产了一条消息: 消息来了！  
7. 消费者 Consumer0 消费了一条消息: 消息来了！  
8. 生产者 Producer0 生产了一条消息: 消息来了！  
9. 消费者 Consumer1 消费了一条消息: 消息来了！  
10. 生产者 Producer2 生产了一条消息: 消息来了！  
11. 消费者 Consumer2 消费了一条消息: 消息来了！  
12. 生产者 Producer0 生产了一条消息: 消息来了！  
13. 消费者 Consumer1 消费了一条消息: 消息来了！  
14. 生产者 Producer1 生产了一条消息: 消息来了！  
15. 消费者 Consumer0 消费了一条消息: 消息来了！  
16. 生产者 Producer2 生产了一条消息: 消息来了！  
17. 消费者 Consumer0 消费了一条消息: 消息来了！  
18. 生产者 Producer1 生产了一条消息: 消息来了！  
19. 生产者 Producer0 生产了一条消息: 消息来了！  
20. 消费者 Consumer2 消费了一条消息: 消息来了！  
21. 消费者 Consumer1 消费了一条消息: 消息来了！  
22. 生产者 Producer1 生产了一条消息: 消息来了！  

多线程应用中，同步与互斥用的特别广泛，这两个是必须要理解并掌握的！