轉：Java同步技術 (一)

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

一、基本同步原理

1.1 同步機制(synchronize mechanism)

1.1.1 同步

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

同步示例: 進程同步:// 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. <臨界區A>
leave(lock); // 3. 離開臨界區(解鎖)
---------------------------------------------------------->
... // 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. <臨界區B> (獲取了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]: <執行: balance=balance+amount>
[T1]:
[T2]: 準備進入: synObject臨界區B //等待T1解鎖
[T1]: 離開: synObject臨界區A
[T2]: 進入: synObject臨界區B //T1已解鎖
[T2]: <執行: balance=balance-amount>
[T2]:
[T1]: <已離開臨界區,與T2并行>
[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