http://www.cnblogs.com/dolphin0520/p/3920385.html
Java並發編程：線程間協作的兩種方式：wait、notify、notifyAll和Condition
在前面我們將了很多關於同步的問題，然而在現實中，需要線程之間的協作。比如說最經典的生產者-消費者模型：當隊列滿時，生產者需要等待隊列有空間才能繼續往里面放入商品，而在等待的期間內，生產者必須釋放對臨界資源（即隊列）的占用權。因為生產者如果不釋放對臨界資源的占用權，那么消費者就無法消費隊列中的商品，就不會讓隊列有空間，那么生產者就會一直無限等待下去。因此，一般情況下，當隊列滿時，會讓生產者交出對臨界資源的占用權，並進入掛起狀態。然后等待消費者消費了商品，然后消費者通知生產者隊列有空間了。同樣地，當隊列空時，消費者也必須等待，等待生產者通知它隊列中有商品了。這種互相通信的過程就是線程間的協作。
今天我們就來探討一下Java中線程協作的最常見的兩種方式：利用Object.wait()、Object.notify()和使用Condition
以下是本文目錄大綱：
一.wait()、notify()和notifyAll()
二.Condition
三.生產者-消費者模型的實現
若有不正之處請多多諒解，並歡迎批評指正。
請尊重作者勞動成果，轉載請標明原文鏈接：
http://www.cnblogs.com/dolphin0520/p/3920385.html
一.wait()、notify()和notifyAll()
wait()、notify()和notifyAll()是Object類中的方法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
/**
* Wakes up a single thread that is waiting on this object's
* monitor. If any threads are waiting on this object, one of them
* is chosen to be awakened. The choice is arbitrary and occurs at
* the discretion of the implementation. A thread waits on an object's
* monitor by calling one of the wait methods
*/
public
final
native
void
notify();
/**
* Wakes up all threads that are waiting on this object's monitor. A
* thread waits on an object's monitor by calling one of the
* wait methods.
*/
public
final
native
void
notifyAll();
/**
* Causes the current thread to wait until either another thread invokes the
* {@link java.lang.Object#notify()} method or the
* {@link java.lang.Object#notifyAll()} method for this object, or a
* specified amount of time has elapsed.
* <p>
* The current thread must own this object's monitor.
*/
public
final
native
void
wait(
long
timeout)
throws
InterruptedException;
|
從這三個方法的文字描述可以知道以下幾點信息：
1）wait()、notify()和notifyAll()方法是本地方法，並且為final方法，無法被重寫。
2）調用某個對象的wait()方法能讓當前線程阻塞，並且當前線程必須擁有此對象的monitor（即鎖）
3）調用某個對象的notify()方法能夠喚醒一個正在等待這個對象的monitor的線程，如果有多個線程都在等待這個對象的monitor，則只能喚醒其中一個線程；
4）調用notifyAll()方法能夠喚醒所有正在等待這個對象的monitor的線程；
有朋友可能會有疑問：為何這三個不是Thread類聲明中的方法，而是Object類中聲明的方法（當然由於Thread類繼承了Object類，所以Thread也可以調用者三個方法）？其實這個問題很簡單，由於每個對象都擁有monitor（即鎖），所以讓當前線程等待某個對象的鎖，當然應該通過這個對象來操作了。而不是用當前線程來操作，因為當前線程可能會等待多個線程的鎖，如果通過線程來操作，就非常復雜了。
上面已經提到，如果調用某個對象的wait()方法，當前線程必須擁有這個對象的monitor（即鎖），因此調用wait()方法必須在同步塊或者同步方法中進行（synchronized塊或者synchronized方法）。
調用某個對象的wait()方法，相當於讓當前線程交出此對象的monitor，然后進入等待狀態，等待后續再次獲得此對象的鎖（Thread類中的sleep方法使當前線程暫停執行一段時間，從而讓其他線程有機會繼續執行，但它並不釋放對象鎖）；
notify()方法能夠喚醒一個正在等待該對象的monitor的線程，當有多個線程都在等待該對象的monitor的話，則只能喚醒其中一個線程，具體喚醒哪個線程則不得而知。
同樣地，調用某個對象的notify()方法，當前線程也必須擁有這個對象的monitor，因此調用notify()方法必須在同步塊或者同步方法中進行（synchronized塊或者synchronized方法）。
nofityAll()方法能夠喚醒所有正在等待該對象的monitor的線程，這一點與notify()方法是不同的。
這里要注意一點：notify()和notifyAll()方法只是喚醒等待該對象的monitor的線程，並不決定哪個線程能夠獲取到monitor。
舉個簡單的例子：假如有三個線程Thread1、Thread2和Thread3都在等待對象objectA的monitor，此時Thread4擁有對象objectA的monitor，當在Thread4中調用objectA.notify()方法之后，Thread1、Thread2和Thread3只有一個能被喚醒。注意，被喚醒不等於立刻就獲取了objectA的monitor。假若在Thread4中調用objectA.notifyAll()方法，則Thread1、Thread2和Thread3三個線程都會被喚醒，至於哪個線程接下來能夠獲取到objectA的monitor就具體依賴於操作系統的調度了。
上面尤其要注意一點，一個線程被喚醒不代表立即獲取了對象的monitor，只有等調用完notify()或者notifyAll()並退出synchronized塊，釋放對象鎖后，其余線程才可獲得鎖執行。
下面看一個例子就明白了：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
public
class
Test {
public
static
Object object =
new
Object();
public
static
void
main(String[] args) {
Thread1 thread1 =
new
Thread1();
Thread2 thread2 =
new
Thread2();
thread1.start();
try
{
Thread.sleep(
200
);
}
catch
(InterruptedException e) {
e.printStackTrace();
}
thread2.start();
}
static
class
Thread1
extends
Thread{
@Override
public
void
run() {
synchronized
(object) {
try
{
object.wait();
}
catch
(InterruptedException e) {
}
System.out.println(
"線程"
+Thread.currentThread().getName()+
"獲取到了鎖"
);
}
}
}
static
class
Thread2
extends
Thread{
@Override
public
void
run() {
synchronized
(object) {
object.notify();
System.out.println(
"線程"
+Thread.currentThread().getName()+
"調用了object.notify()"
);
}
System.out.println(
"線程"
+Thread.currentThread().getName()+
"釋放了鎖"
);
}
}
}
|
無論運行多少次，運行結果必定是：
線程Thread-1調用了object.notify()
線程Thread-1釋放了鎖 線程Thread-0獲取到了鎖
二.Condition
Condition是在java 1.5中才出現的，它用來替代傳統的Object的wait()、notify()實現線程間的協作，相比使用Object的wait()、notify()，使用Condition1的await()、signal()這種方式實現線程間協作更加安全和高效。因此通常來說比較推薦使用Condition，在阻塞隊列那一篇博文中就講述到了，阻塞隊列實際上是使用了Condition來模擬線程間協作。
- Condition是個接口，基本的方法就是await()和signal()方法；
- Condition依賴於Lock接口，生成一個Condition的基本代碼是lock.newCondition()
- 調用Condition的await()和signal()方法，都必須在lock保護之內，就是說必須在lock.lock()和lock.unlock之間才可以使用
Conditon中的await()對應Object的wait()；
Condition中的signal()對應Object的notify()；
Condition中的signalAll()對應Object的notifyAll()。
三.生產者-消費者模型的實現
1.使用Object的wait()和notify()實現：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
|
public
class
Test {
private
int
queueSize =
10
;
private
PriorityQueue<Integer> queue =
new
PriorityQueue<Integer>(queueSize);
public
static
void
main(String[] args) {
Test test =
new
Test();
Producer producer = test.
new
Producer();
Consumer consumer = test.
new
Consumer();
producer.start();
consumer.start();
}
class
Consumer
extends
Thread{
@Override
public
void
run() {
consume();
}
private
void
consume() {
while
(
true
){
synchronized
(queue) {
while
(queue.size() ==
0
){
try
{
System.out.println(
"隊列空，等待數據"
);
queue.wait();
}
catch
(InterruptedException e) {
e.printStackTrace();
queue.notify();
}
}
queue.poll();
//每次移走隊首元素
queue.notify();
System.out.println(
"從隊列取走一個元素，隊列剩余"
+queue.size()+
"個元素"
);
}
}
}
}
class
Producer
extends
Thread{
@Override
public
void
run() {
produce();
}
private
void
produce() {
while
(
true
){
synchronized
(queue) {
while
(queue.size() == queueSize){
try
{
System.out.println(
"隊列滿，等待有空余空間"
);
queue.wait();
}
catch
(InterruptedException e) {
e.printStackTrace();
queue.notify();
}
}
queue.offer(
1
);
//每次插入一個元素
queue.notify();
System.out.println(
"向隊列取中插入一個元素，隊列剩余空間："
+(queueSize-queue.size()));
}
}
}
}
}
|
2.使用Condition實現
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
|
public
class
Test {
private
int
queueSize =
10
;
private
PriorityQueue<Integer> queue =
new
PriorityQueue<Integer>(queueSize);
private
Lock lock =
new
ReentrantLock();
private
Condition notFull = lock.newCondition();
private
Condition notEmpty = lock.newCondition();
public
static
void
main(String[] args) {
Test test =
new
Test();
Producer producer = test.
new
Producer();
Consumer consumer = test.
new
Consumer();
producer.start();
consumer.start();
}
class
Consumer
extends
Thread{
@Override
public
void
run() {
consume();
}
private
void
consume() {
while
(
true
){
lock.lock();
try
{
while
(queue.size() ==
0
){
try
{
System.out.println(
"隊列空，等待數據"
);
notEmpty.await();
}
catch
(InterruptedException e) {
e.printStackTrace();
}
}
queue.poll();
//每次移走隊首元素
notFull.signal();
System.out.println(
"從隊列取走一個元素，隊列剩余"
+queue.size()+
"個元素"
);
}
finally
{
lock.unlock();
}
}
}
}
class
Producer
extends
Thread{
@Override
public
void
run() {
produce();
}
private
void
produce() {
while
(
true
){
lock.lock();
try
{
while
(queue.size() == queueSize){
try
{
System.out.println(
"隊列滿，等待有空余空間"
);
notFull.await();
}
catch
(InterruptedException e) {
e.printStackTrace();
}
}
queue.offer(
1
);
//每次插入一個元素
notEmpty.signal();
System.out.println(
"向隊列取中插入一個元素，隊列剩余空間："
+(queueSize-queue.size()));
}
finally
{
lock.unlock();
}
}
}
}
}
|
- 摘要：通過之前討論的鎖對象,我們知道了,由於線程按照時間片調度,所以使用鎖對象來在多線程共享資源時保護未執行完成的線程安全。那么,我們再來考慮這樣一種情況:如果我的線程執行過程中因為沒有滿足一些必要的條件而導致線程暫停執行怎么辦?比如,我們還用銀行賬戶系統做例子,如果有一條線程是從我的賬戶轉出1000元到其他賬戶,可是我的賬戶余額不足1000元,那么怎么辦?也許你會直接簡單地想到,加上一個if條件語句做一下判斷不就可以了,就像這樣:if(bank.getBalance(from)&
通過之前討論的鎖對象,我們知道了,由於線程按照時間片調度,所以使用鎖對象來在多線程共享資源時保護未執行完成的線程安全。那么,我們再來考慮這樣一種情況:
如果我的線程執行過程中因為沒有滿足一些必要的條件而導致線程暫停執行怎么辦?
比如,我們還用銀行賬戶系統做例子,如果有一條線程是從我的賬戶轉出 1000 元到其他賬戶,可是我的賬戶余額不足 1000 元,那么怎么辦?也許你會直接簡單地想到,加上一個 if 條件語句做一下判斷不就可以了,就像這樣:
-
if (bank.getBalance(from) >= amount)
-
bank.transfer(from, to, amount);
但是,要注意,千萬不能這樣寫,因為,很有可能會出現這樣的情況:
1. 先執行 if 語句檢查我的賬戶余額,余額滿足條件
2. 線程時間片結束被中斷暫停
3. 在這期間執行了一條從我的賬戶取錢的線程,取出錢后余額就不足了
4. 線程恢復執行,此時余額不足但是已經執行完畢了 if 語句
由此可見,這樣的代碼藏有致命的 bug ,那么,我再來做修改,也許我們可以把鎖對象用上,這樣即使線程暫停也不會受影響了。是的,這樣做確實可以防止其他線程對余額的操作,可是,這里面還是有問題:
比如,我的余額一開始就不夠,這時恰好也有一個存錢的線程進來,如果錢能順利存進來我的余額就足夠了,可是,我們的鎖對象卻把存錢線程拒之門外,這樣反而不利於線程的順利執行了
鑒於此,我們就需要引入條件對象
通過調用 newCondition 方法可以獲得一個條件對象,而且,應該養成一個給每個條件對象起個好名字的習慣,應該用其所表達的條件為其命名,這樣使人一目了然。在文中的例子中,我們用 sufficientFunds(余額充足)作為條件對象的名字
-
class Bank{
-
private Condition sufficientFunds;
-
...
-
public Bank(){
-
...
-
sufficientFunds = bankLock.newCondition();
-
}
-
}
如果 transfer 方法發現余額不足的時候,就會調用:
sufficientFunds.await( );
這時,當前線程就被阻塞(Blocked)了,並且放棄了鎖對象,等待着其他的線程滿足它所需的條件
等待獲得鎖的線程和調用 await 的線程存在本質上的不同,一旦一個線程調用 await 方法,它進入該條件的等待集,當鎖可用時,該線程不能馬上解除阻塞,相反,它處於阻塞狀態,直到另一個線程調用同一條件上的 signalAll 方法為止
在本例中,當我們的條件對象調用 await 方法處於阻塞狀態時,它就在等待一個轉賬存錢的線程來滿足它的條件,因此,我們在寫代碼時,就可以為轉賬存錢的線程最后調用 sufficientFunds.signalAll( ) 方法
這一調用重新激活因為這一條件而等待的所有線程,當這些線程從等待集中移出時,它們再次成為可運行的,調度器將再次激活它們。同時,它們將試圖重新進入該對象。一旦鎖成為可用的,它們中的某個將從 await 調用返回,獲得該鎖並從被阻塞的地方繼續執行。
因此,當條件對象被重新激活從 await 返回時,應該再次測試條件,因為即使我的賬戶已經有了收入,條件還不一定被滿足
我們應該將 await 調用放入循環體中
-
while (條件沒有被滿足)
-
condition.await();
我們還應該注意的是,當一個線程調用 await 后,它無法激活自身,只能依靠等待其他的線程來滿足它的條件才能繼續執行,如果沒有其他線程滿足它的條件,它將永遠無法繼續執行,這就是 死鎖 現象
那么,應該在什么時候調用 signalAll 方法呢?應該在每次對象狀態有利於等待線程的方向改變時調用。也就是本例中,一個賬戶余額發生改變時調用
綜上所述,最終的 transfer 方法應該寫成這樣:
-
public void transfer(int from, int to, int amount){
-
bankLock.lock();
-
try{
-
while(accounts[from] < amount)
-
sufficientFunds.await();
-
// transfer funds
-
...
-
sufficientFunds.signalAll();
-
}
-
finally{
-
bankLock.unlock();
-
}
-
}
最后還要注意,Java 中有 signal 和 signalAll 兩種方法,signal 是隨機解除一個等待集中的線程的阻塞狀態,signalAll 是解除所有等待集中的線程的阻塞狀態。signal 方法的效率會比 signalAll 高,但是它存在危險,因為它一次只解除一個線程的阻塞狀態,因此,如果等待集中有多個線程都滿足了條件,也只能喚醒一個,其他的線程可能會導致死鎖
-