本文版權歸作者Ian Gao所有，如有轉載請與作者聯絡並註明出處http://blog.csdn.net/Iangao/archive/2008/10/09/3041265.aspx。

一、基本同步原理

1.1 同步機制(synchronize mechanism)

1.1.1 同步

多執行緒開發過程中，我們經常會提到同步這個詞，那麼什麼是同步呢？為什麼會存在同步問題呢？我們知道一個多執行緒應用系統在作業系統的程式（執行緒）機制下可以同時有多個程式（執行緒）併發執行，這此程式（執行緒）要完成的任務可能是互不相關的，但也可能是有聯絡的。那麼當一個程式（執行緒）要和另一個程式（執行緒）交流資訊時同步就有可能發生了。為什麼呢？如果您不清，看了下面這個例子也許就會明白了。

[@more@]

同步示例: 程式同步:// http://www.csdn.net/blog/Iangao
在日常生活中我們經常會遇到定蛋糕的事，過程是什麼樣的呢？讓我們一起來回顧一下。
首先是我們做我們的事，蛋糕師傅也做道自已的事，當我們想要買蛋糕時，我們就要和蛋糕師打交道了。
我們選好蛋糕樣式，交款完款，把定單交給蛋糕師後由於時間製作時間很長,所以出去逛20分鐘的街,然後回來拿著小票等待蛋糕被做好了。
蛋糕師則是一上班就在等待定單，當他拿到定單後，開始按照要求進行製作，做好後把這蛋糕放到貨架上，然後根據定單上的連繫方式通知我們來取貨。
接到通知單後，我們便可以拿著蛋糕回家了。而蛋糕師還將繼續做著他自已的事情。貨架，定單，取貨通知單
顧客程式師傅程式
顧客(){
選擇蛋糕() // 1.(並行)

交款() // 2.(並行)
出示(定單) // 3. (同步1)
逛街(20分鐘) // 4. (並行)
等待(取貨) // 5. (同步2)
// http://www.csdn.net/blog/Iangao

取蛋糕(貨架) // 7. (並行)
回家() // 8. (並行)

}// http://www.csdn.net/blog/Iangao 製作(){
準備製作() // 1(並行)
while(true){
等待(定單) // 2.(同步1)

製作(30分鐘) // 4.(並行)
放入蛋糕(貨架) // 5.
通知(取貨) // 6. (同步2)
... // 7. (並行)
}
}

我們分析一下上面的例子，在例子中，我們可以看出由於沒有定單，師傅程式在“同步1”處不得不停下來等待一個定單，直到有定單時它才可以製作蛋糕。同樣的，由於蛋糕尚未做好，因此顧客執行緒也在“同步2”處停下來等待，直到接到取貨通知單後才取蛋糕回家。現在我們可以總結一下：同步(synchronize)實際上就是讓一個執行緒停下腳步處於等待狀態直到另一個執行緒向它發出繼續執行的訊號後，兩個執行緒再繼續併發執行的一種執行緒間的通訊機制。而透過上面的例子我們可以總結出“要想實現這種機制起碼應該具備如下三個基本要素”：

一個用於通訊的訊號(signal)
一個用於等待訊號的操作(wait)
一個用於傳送訊號的操作(notify)
這種機制在Solaris或POSIX執行緒中，它們通常被看做是條件變數(condition variable), 而在Windows系統中它們往往被看成是事件變數(event variable),不過兩者還是有一些區別的，我們將在後面的章節中繼續深入討論。

1.1.2 臨界區、鎖

在同步問題中，有一類是由於對共享資源併發使用而引起的。眾所周知一組資源(資料)被多個程式(執行緒)同時使用，往往會造成邏輯紊亂(有的在讀，有的在改），為了避免這一情況，就要求對資源的使用加以控制，使得程式(執行緒)在訪問資源期間，不允許被其他程式(執行緒）干擾。有干擾的執行緒必須處於等待狀態中。通常我們把這段不受干擾的使用某一特定資源的段碼段稱為該資源的臨界區(critical section)。而臨界區就象對資源加了一把鎖（Lock)，進的時候加鎖(lock)，出的時解鎖(unlock)，這就可以把所有有干擾的程式（執行緒）鎖都到臨界區之外。下面我們分析一下用於定義臨界區的鎖操作都完成了什麼功能，請看下面的一個最簡單的功能性說明程式碼清單(下圖參考自《作業系統》一書):

shared double balance, account; //共享變數
shared int lock=FALSE; //同步變數(Mutex): 用於實現控制對balance和account資源訪問的鎖
Program for P1 [ Credit(貸) ]
// http://www.csdn.net/blog/Iangao
...
enter(lock); // 1. 進入臨界區(加鎖)
balance=balance+account; // 2.
leave(lock); // 3. 離開臨界區(解鎖)
----------------------------------------------------------&gt
... // 4. 繼續P1任務 Program for P1 [ Debit(借) ]
// http://www.csdn.net/blog/Iangao
...
enter(lock); // 2. 等待P1解鎖
// http://www.csdn.net/blog/Iangao

balance=balance-account; // 4. (獲取了P1釋放的鎖)
leave(lock); // 5. 解鎖
...

1.1.3 互斥鎖

隨著後面不斷深入的討論，我們會發現有些臨界區的鎖是可以有限度的，它只阻止一部分可以引起相互干擾的程式（執行緒）進入臨界區，而不會阻止互不干擾的程式(執行緒)進入，這時可能會有幾個程式(執行緒)併發的使用。不過本節我們只討論其中一種最簡單的鎖，一種會阻隔一切想要進入臨界區內執行緒的鎖，由於它具有極強的排它性，因此我們稱它為互斥量(Mutex lock)。同樣由於它具有排它性，我們一般會用它來定義一個原子（atomic）操作，因為它可以很好的保證對某一資源操作的不可分割性(individed)。下面我們簡單定義了一個mutex的基本語義:

// 加鎖:原子操作
enter(mutex){
while(mutex) wait(); // 等待
mutex=TRUE; // 標識資源忙
} // 解鎖:原子操作
leave(mutex){
mutex=FALSE; // 標識資源可用
notify();
}

考虎到mutex是用於定義原子操作的，因此我們在實現時會對加鎖和解鎖操作進行一定的約束，約束如下：

最後,為了保證臨界的原子性(atomic)，通常對一個互斥量Mutex做解鎖操作的程式(執行緒)一定是前面對其進行加鎖操作的程式。而不允許被其他程式(執行緒)解鎖。下面的程式碼清單演示了臨界區與鎖的工作原理:如果P1執行到balance=balance+account時P2執行到了enter(lock)，那麼由於P1對"lock資源"已經加鎖了，此時P2只處於等待狀態。直到P1執行完exit(lock)後才釋放了對"lock資源"的控制權，這時P2使可以執行enter(lock)操作，繼而在獨佔lock資源的情況下完成臨界區中的程式碼示意圖。

1.2 Java中的同步機制

1.2.1 synchronized關鍵字

1 定義臨界區:

Java為了實現同步機制提供了synchronized關鍵字，我們可以使用它來定義被同步的物件以及臨界區，臨界區的範圍是由一組大括號來標識的。而進出臨界區時必要的加鎖和解鎖操作則是由Java內建支援的。從功能上來說，我們可以認為左大括號起到enter(lock)的作用，而右大括號起到了exit(lock)的作用。下面清單中演示了synchronized與互斥鎖理論功能上的的對應關係。

private double balance, account; //共享變數
private Object lock=new Object(); //同步物件

Program for P1
...
synchronized(lock){ // 獲取資源並加鎖
balance=balance+account; //
} // 釋放資源並解鎖
... shared double balance, account; //共享變數
shared int lock=FALSE; //同步變數

Program for P1
...
enter(lock); // 獲取資源並加鎖
balance=balance+account; //
exit(lock); // 釋放資源並解鎖
...

2 定義同步物件:

我們知道了如何定義臨界區，但這還不夠，我們還需要知道如何定義這段臨界區要同步的物件(資料).在Java中有下面的兩種使用synchronized的方式，我們分別看一下它們是如何定義被同步的物件的：

一種是直接“宣告同步(synchronized)物件”: 這種方式的同步物件被明確的指定在了sychronized後的小括號，而其後的一組大括號內定義的正是臨界區。這種方式使用起來很靈活，可以只對方法中的一段不可分割的程式碼做同步，因此臨界區比較小，所以效率也就可以比較高了。下面清單中演示了這一用法的使用。
/**
* 宣告同步物件示例,參看上節示例
* @author iangao
*/// http://www.csdn.net/blog/Iangao
public class Foo {
private double balance, amount; //共享資源
private Object synObject=new Object(); //同步物件
/**
* 參看上節: [Program for P1]
*/
public void f(){
...
// 進入臨界區,鎖定對synObj的訪問
synchronized(synObject){ // 臨界區A
balance=balance+amount;
...// http://www.csdn.net/blog/Iangao
doSomethingInCriticalSectionA();
}
// 退出臨界區,釋放對synObj的鎖定// http://www.csdn.net/blog/Iangao
...
}// http://www.csdn.net/blog/Iangao
/**
* 參看上節: [Program for P2]
*/
public void g(){// http://www.csdn.net/blog/Iangao
...
synchronized(synObject){ // 臨界區B
balance=balance-amount;
...
doSomethingInCriticalSectionB();
}
....// http://www.csdn.net/blog/Iangao
}
}

另一種是“宣告同步(synchronized)方法”：這種方式是把整個方法的實現都劃入了臨界區.但它同步的是哪個物件呢？實際上這種方式是隱式的對this物件做同步的，相當於一進入方法就對this物件做同步操作[即synchronized(this){}]，直到方法結束再解除同步。不過因為是對整個方法做同步，所以有時會顯得效率不高，只是它用起來很方便。以下清單中描述了synchronized的這種用法，右邊演示了重構成第一種使用方式時的樣子。
/**
* 宣告同步方法示例（管程的Java實現）
* @author iangao
*/
public class Foo2 {// http://www.csdn.net/blog/Iangao
private double balance, amount; //共享資源
public synchronized void f(){ // 監界區C
balance=balance+amount;
}// http://www.csdn.net/blog/Iangao
public synchronized void g(){ // 監界區D
balance=balance-amount;
}
}// http://www.csdn.net/blog/Iangao /**
* 按照同步物件的方法重構Foo2後
* @author iangao
*/
public class Foo2 {
private double balance, amount; //共享資源
public void f(){
synchronized(this){ // 監界區C
balance=balance+amount;
}
}
public void g(){
synchronized(this){ // 監界區D
balance=balance-amount;
}
}
}

其實，透過sychronized關鍵字定義的同步物件，我們一般稱它為管程物件(Monitor)，在後面我們還會對管程進行詳細討論。在此不再多述。

3 同步測試

測試1.1.3.2中synchronized同步示例，為了達到測試的目的可以分別在臨界區A,B,C,D中加入延時操作Thread.sleep(3000)並輸出一些除錯資訊。這樣就可以得到可見的同步效果顯示了。測試程式碼可以參看下面的清單:

/**
* 同步物件測試
* @author iangao
*/
public class SynchronizedObjectTest {
public static void main(String[] args){
// 定義要同步的兩段程式碼
new ThreadsTest(){
private Foo foo=new Foo();
void runInThread1() { //
foo.f(); // 線上程1中執行foo.f()
}// http://www.csdn.net/blog/Iangao
void runInThread2() { //
foo.g(); // 線上程2中執行foo.g()
}// http://www.csdn.net/blog/Iangao
}.execute(2); // 執行同步測試(啟動2個執行緒)
}// http://www.csdn.net/blog/Iangao
} 測試結果:
[T1]: 準備進入: synObject臨界區A
[T1]: 進入: synObject臨界區A
[T1]:
[T1]:
[T2]: 準備進入: synObject臨界區B //等待T1解鎖
[T1]: 離開: synObject臨界區A
[T2]: 進入: synObject臨界區B //T1已解鎖
[T2]:
[T2]:
[T1]:
[T1]:
[T2]: 離開: synObject臨界區B
[T2]:

4. 物件鎖與類鎖

在Java中,用synchronized定義的都有兩種鎖,一個種是物件鎖(每個物件有一把鎖), 一種是類鎖(每個class有一把鎖),前面討論的主要是物件鎖,下我們用一個例子來研究物件鎖與類鎖的區別:

/**
* 類鎖測試
* @author iangao
*/
public class ClassLockTest extends ThreadsTest{

public void runInThread1(){ g(); }
public void runInThread2(){ f(); }
// http://www.csdn.net/blog/Iangao
/**
* 同步的是類鎖(class lock)
*/
public static synchronized void f(){
output("enter f");
sleep(1000);
output("leave f");
}// http://www.csdn.net/blog/Iangao
/**
* 同步的是物件鎖(object lock),
* f,g必須同時為static或非static同步才會成立
*/
public synchronized void g(){
output("enter g");
sleep(1000);// http://www.csdn.net/blog/Iangao
output("leave g");
}// http://www.csdn.net/blog/Iangao
public static void main(String[] args){
new ClassLockTest().execute(2);
}// http://www.csdn.net/blog/Iangao
}
執行結果:
[T1]: enter g
[T2]: enter f
[T1]: leave g
[T2]: leave f

結論:

static方法定義的是類鎖, 而非static方法定義的是物件鎖. 因為兩個方法同步的不是同一個鎖,所以同步失效.

執行結果2(把g改成static後的):
[T1]: enter g
[T1]: leave g
[T2]: enter f
[T2]: leave f

結論:

此時兩個方法都是同步的class鎖, 同步成功!

1.2.2 wait-notify機制

1.2.2.1 wait、notify簡介

Java語言為我們提供了一套用於執行緒間同步的通訊機制即wait-nofity機制。前面我們知道了，sychronized關鍵字可以讓我們把任何一個Object物件做為同步物件來看待,而Java為每個Object都實現了wait()和notify()方法。它們必須用在被sychronized同步的Object的臨界區內。透過的wait()我們可以使得處於臨界區內的執行緒進入阻塞狀態，同時釋放被同步物件的控制權，而notify操作可以喚醒一個因呼叫了wait操作而處於阻塞狀態中的執行緒,使其進入就緒狀態。被重新換醒的執行緒會試圖重新獲得臨界區的控制權，並繼續執行臨界區內wait之後面的程式碼。如果發出notify操作時沒有處於阻塞狀態中的執行緒,那麼該訊號會被忽略.

/**
* Wait/Notify 機制測試
* @author iangao
*/// http://www.csdn.net/blog/Iangao
public class WaitNotifyTest {
public static void main(String[] args){
new ThreadsTest(){
Object obj=new Object();
void runInThread1()
throws InterruptedException{
waiter();
}// http://www.csdn.net/blog/Iangao
void runInThread2(){
sleep(100);
notifyer();
}// http://www.csdn.net/blog/Iangao
void runInThread3(){
sleep(1000);
notifyer();
}// http://www.csdn.net/blog/Iangao
void runInThread4()
throws InterruptedException{
sleep(6000);
waiter();
}// http://www.csdn.net/blog/Iangao
/**
* WAITER
*/
void waiter()
throws InterruptedException {
output("");
synchronized(obj){
output("enter");
int i=0;
for(;i<3;i++)
output(""+i,500);
output("wait...");
obj.wait();
output("back");
for(;i<5;i++)
output(""+i,100);
output("leave");
}
}// http://www.csdn.net/blog/Iangao
/**
* NOTIFYER
*/
void notifyer() {
output("");
synchronized(obj){
int i=0;
output("enter");
for(;i<2;i++)
output(""+i,1000);
output("notify");
obj.notify();
for(; i<4; i++)
output(""+i,100);
output("leave");
}
}// http://www.csdn.net/blog/Iangao
}.execute(4);
}// http://www.csdn.net/blog/Iangao
}// http://www.csdn.net/blog/Iangao
execute(2)執行結果：
[T1]:
[T1]: enter
[T1]: 0... (0.5秒)
[T2]: [1]
[T1]: 1... (0.5秒)
[T1]: 2... (0.5秒)
[T1]: wait...
[T2]: enter [2]
[T2]: 0... (1.0秒)
[T2]: 1... (1.0秒)
[T2]: notify [3]
[T2]: 2... (0.1秒)
[T2]: 3... (0.1秒)
[T2]: leave
[T1]: back [4]
[T1]: 3... (0.1秒)
[T1]: 4... (0.1秒)
[T1]: leave
execute(4)執行結果:
[T1]:
[T1]: enter
[T1]: 0... (0.5秒)
[T2]:
[T1]: 1... (0.5秒)
[T1]: 2... (0.5秒)
[T3]:
[T1]: wait... [1]
[T2]: enter
[T2]: 0... (1.0秒)
[T2]: 1... (1.0秒)
[T2]: notify [2]
[T2]: 2... (0.1秒)
[T2]: 3... (0.1秒)
[T2]: leave
[T3]: enter [3]
[T3]: 0... (1.0秒)
[T3]: 1... (1.0秒)
[T3]: notify [4]
[T3]: 2... (0.1秒)
[T3]: 3... (0.1秒)
[T3]: leave
[T1]: back [5]
[T1]: 3... (0.1秒)
[T4]:
[T1]: 4... (0.1秒)
[T1]: leave
[T4]: enter
[T4]: 0... (0.5秒)
[T4]: 1... (0.5秒)
[T4]: 2... (0.5秒)
[T4]: wait... [6]

分析:
T2要進入臨界區時會由於T1掌控臨界區而等待。
wait()操作使得T1進入了阻塞狀態並釋放了透過syncrhonized同步的物件obj的控制權,這使得T2可以進入臨界區
T2的notify()可以喚醒T1，但由於並不立即釋放對obj的控制權，因此這時的T1處於就緒狀態
T1直到T2退出臨界區後才重獲控制權，並繼續後面的業務
分析:
T1 wait時雖然有T2,T3在等待，但也只能有一個執行緒進入臨界區.
由於在T2 notify之前T3已處於就緒狀態中，加上notify後的T1就有兩個處於就緒中的執行緒等待進入臨界區了
在T2離開臨界區時，有可能被T3先搶到臨界區，這時雖然T1已被T2喚醒，但仍要繼續等待。
T3傳送notify訊號時，系統並沒有阻塞的執行緒，因此這個訊號實際上根本沒起作用。
T1終於在T3結束後重獲了臨界區的控制權，不過時這離T2的snotify操作已經很久了。
T4的wait操作由於沒有notify來啟用，因此它會一直等下去，至於先前T3的notify是不會對後面的wait起作用的。

透過上面一系列的測試與分析，我們可以得出一個得要結論，那就是“wait()對notify()的響應很有可能是不及時的”，之所以強調這一點是因為它往往會由於響應不及時而造成響應時的系統狀態與發出notify時的不一致，所以在實際應用中我們要多加註意這一點，尤其是在那些與狀態有關的同步應用中這點尤為重要。

1.2.2.2 notify 與 notifyAll

notify的只能喚醒一個透過呼叫wait而等待的執行緒, notifyAll可以喚醒所有呼叫wait或因synchronized關鍵字而等待的執行緒. 不過透過notifyAll喚醒的所有執行緒也必須按照上節分析的過程,依次進入臨界區.

1.2.3 wait與sleep的比較

// http://www.csdn.net/blog/Iangao wait() sleep()
所屬物件 Object Thread
阻塞當前執行緒可以可以
使用條件必須在管程(Monitor)內使用,即所屬Object必須已被sychronized同步。隨時
管程(Monitor)內使用效果
(synchronized臨界區內) 釋放對管程物件(Monitor)的控制權不釋放對管程物件(Monitor)控制權
喚醒 notify() 無

發表於 @ 2008年10月09日 11:52:00|評論(0)|收藏

新一篇: Java同步技術(二) |

本文來自CSDN部落格，轉載請標明出處：http://blog.csdn.net/Iangao/archive/2008/10/09/3041265.aspx

轉：Java同步技術 (一)

相關文章