Java多線程編程--（3）線程互斥、同步的理解

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

多線程並行編程中，線程間同步與互斥是一個很有技巧的也很容易出錯的地方。

線程間互斥應對的是這種場景：多個線程操作同一個資源（即某個對象），爲保證線程在對資源的狀態（即對象的成員變量）進行一些非原子性操作後，狀態仍然是正確的。典型的例子是“售票廳售票應用”。售票廳剩餘100張票，10個窗口去賣這些票。這10個窗口，就是10條線程，售票廳就是他們共同操作的資源，其中剩餘的100張票就是這個資源的一個狀態。線程買票的過程就是去遞減這個剩餘數量的過程。不進行互斥控制的代碼如下：

[java] view plain copy

package cn.test;
public class TicketOffice {
private int ticketNum = 0;
public TicketOffice(int ticketNum) {
super();
this.ticketNum = ticketNum;
}
public int getTicketNum() {
return ticketNum;
}
public void setTicketNum(int ticketNum) {
this.ticketNum = ticketNum;
}
/**
* 售票廳賣票的方法，這個方法操作了售票廳對象唯一的狀態--剩餘火車票數量。
* 該方法此處並未進行互斥控制。
*/
public void sellOneTicket(){
ticketNum--;
// 打印剩餘票的數量
if(ticketNum >= 0){
System.out.println("售票成功，剩餘票數： " + ticketNum);
}else{
System.out.println("售票失敗，票已售罄！");
}
}
public static void main(String[] args) {
final TicketOffice ticketOffice = new TicketOffice(100);
// 啓動10個線程，即10個窗口開始賣票
for(int i=0;i<10;i++){
new Thread(new Runnable(){
@Override
public void run() {
// 當還有剩餘票的時候，就去執行
while(ticketOffice.getTicketNum() > 0){
ticketOffice.sellOneTicket();
}
}
}).start();
}
}
}

最後打印的部分結果如下：

[plain] view plain copy

售票成功，剩餘票數： 93
售票成功，剩餘票數： 92
售票成功，剩餘票數： 91
售票成功，剩餘票數： 95
售票成功，剩餘票數： 96
售票成功，剩餘票數： 87
售票成功，剩餘票數： 86
售票成功，剩餘票數： 88
售票成功，剩餘票數： 89
售票成功，剩餘票數： 83
售票成功，剩餘票數： 82
售票成功，剩餘票數： 81
售票成功，剩餘票數： 90
售票成功，剩餘票數： 79
售票成功，剩餘票數： 93

可以看到售票廳資源的狀態：剩餘票的數量，是不正確的。數量忽大忽小，這就是對統一資源進行操作沒有控制互斥的結果。
互斥操作的控制，Java提供了關鍵字synchronized進行的。synchronized可以修飾方法，也可以修飾代碼段。其代表的含義就是：進入他修飾的這段代碼內的線程必須先去獲取一個特定對象的鎖定標示，並且虛擬機保證這個標示一次只能被一條線程擁有。通過這兩種方式修改上述代碼的方法sellOneTicket()，如下：

[java] view plain copy

/**
* 已經進行了互斥控制。這裏是通過synchronized修飾整個方法實現的。
* 線程想進入這個方法，必須獲取當前對象的鎖定表示！
*/
public synchronized void sellOneTicket(){
ticketNum--;
// 打印剩餘票的數量
if(ticketNum >= 0){
System.out.println("售票成功，剩餘票數： " + ticketNum);
}else{
System.out.println("售票失敗，票已售罄！");
}
}
/**
* 已經進行了互斥控制。這裏是通過synchronized修飾代碼塊實現的。線程要想進入修飾的代碼塊，
* 必須獲取lock對象的對象標示。
*/
private Object lock = new Object(); //確保整個過程中lock對象不能被改變
public void sellOneTicket2(){
synchronized(lock){
ticketNum--;
// 打印剩餘票的數量
if(ticketNum >= 0){
System.out.println("售票成功，剩餘票數： " + ticketNum);
}else{
System.out.println("售票失敗，票已售罄！");
}
}
}

通過互斥控制後的輸出爲：非常整齊，不會出現任何狀態不對的情況。

[java] view plain copy

售票成功，剩餘票數： 99
售票成功，剩餘票數： 98
售票成功，剩餘票數： 97
售票成功，剩餘票數： 96
售票成功，剩餘票數： 95
售票成功，剩餘票數： 94
售票成功，剩餘票數： 93
售票成功，剩餘票數： 92
售票成功，剩餘票數： 91
售票成功，剩餘票數： 90
售票成功，剩餘票數： 89
售票成功，剩餘票數： 88
售票成功，剩餘票數： 87
售票成功，剩餘票數： 86
售票成功，剩餘票數： 85
售票成功，剩餘票數： 84
售票成功，剩餘票數： 83
售票成功，剩餘票數： 82

同步的概念再於線程間通信，比較典型的例子就是“生產者-消費者問題”。

多個生產者和多個消費者就是多條執行線程，他們共同操作一個數據結構中的數據，數據結構中有時是沒有數據的，這個時候消費者應該處於等待狀態而不是不斷的去訪問這個數據結構。這裏就涉及到線程間通信（當然此處還涉及到互斥，這裏暫不考慮這一點），消費者線程一次消費後發現數據結構空了，就應該處於等待狀態，生產者生產數據後，就去喚醒消費者線程開始消費。生產者線程某次生產後發現數據結構已經滿了，也應該處於等待狀態，消費者消費一條數據後，就去喚醒生產者繼續生產。

實現這種線程間同步，可以通過Object類提供的wait，notify， notifyAll 3個方法去進行即可。一個簡單的生產者和消費者的例子代碼爲：

[java] view plain copy

package cn.test;
public class ProducerConsumer {
public static void main(String[] args) {
final MessageQueue mq = new MessageQueue(10);
// 創建3個生產者
for(int p=0;p<3;p++){
new Thread(new Runnable(){
@Override
public void run() {
while(true){
mq.put("消息來了！");
// 生產消息後，休息100毫秒
try {
Thread.currentThread().sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}, "Producer" + p).start();
}
// 創建3個消費者
for(int s=0;s<3;s++){
new Thread(new Runnable(){
@Override
public void run() {
while(true){
mq.get();
// 消費消息後，休息100毫秒
try {
Thread.currentThread().sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}, "Consumer" + s).start();
}
}
/**
* 內部類模擬一個消息隊列，生產者和消費者就去操作這個消息隊列
*/
private static class MessageQueue{
private String[] messages;// 放置消息的數據結構
private int opIndex; // 將要操作的位置索引
public MessageQueue(int size) {
if(size <= 0){
throw new IllegalArgumentException("消息隊列的長度至少爲1！");
}
messages = new String[size];
opIndex = 0;
}
public synchronized void put(String message){
// Java中存在線程假醒的情況，此處用while而不是用if！可以參考Java規範！
while(opIndex == messages.length){
// 消息隊列已滿，生產者需要等待
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
messages[opIndex] = message;
opIndex++;
System.out.println("生產者 " + Thread.currentThread().getName() + " 生產了一條消息: " + message);
// 生產後，對消費者進行喚醒
notifyAll();
}
public synchronized String get(){
// Java中存在線程假醒的情況，此處用while而不是用if！可以參考Java規範！
while(opIndex == 0){
// 消息隊列無消息，消費者需要等待
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
String message = messages[opIndex-1];
opIndex--;
System.out.println("消費者 " + Thread.currentThread().getName() + " 消費了一條消息: " + message);
// 消費後，對生產者進行喚醒
notifyAll();
return message;
}
}
}