Java使用wait/notify實現線程間通信上篇
線程是操作系統(tǒng)中獨立的個體，但這些個體如果不經過特殊的處理就不能成為一個整體。線程間的通信就是成為整體的必用方案之一，使用線程間進行通信后，系統(tǒng)之間的交互性會更強大，大大提高CPU利用率。
等待/通知機制
（1）不使用等待/通知機制實現線程間通信
樣例代碼如下：
public class TestC2 {
public static void main(String[] args) throws Exception {
MyList myList = new MyList();
ThreadA threadA = new ThreadA(myList);
threadA.setName("A");
ThreadB threadB = new ThreadB(myList);
threadB.setName("B");
threadB.start();
threadA.start();
}
}
class MyList {
volatile private List list = new ArrayList();
public void add() {
list.add("NanJing");
}
public int size() {
return list.size();
}
}
class ThreadA extends Thread {
private MyList myList;
public ThreadA(MyList myList) {
this.myList = myList;
}
@Override
public void run() {
try {
for (int i=0; i<10; i++) {
myList.add();
System.out.println("添加了" + (i+1) + "個元素");
Thread.sleep(1000);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class ThreadB extends Thread {
private MyList myList;
public ThreadB(MyList myList) {
this.myList = myList;
}
@Override
public void run() {
try {
while (true) {
int myListSize = myList.size();
if (myListSize == 5) {
System.out.println("myList長度等于5了，線程需要退出了");
throw new InterruptedException();
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}執(zhí)行結果：
分析：
程序運行后的效果如上圖所示：
雖然 ThreadA 和 ThreadB 實現了通信，但有一個弊端就是，ThreadB 需要不停地通過 while 語句輪詢機制來檢測某一個條件，這樣會浪費CPU資源。
如果輪詢的時間間隔很小，更浪費CPU資源；如果輪詢的時間間隔很大，有可能會取不到想要得到的數據。所以就需要有一種機制來實現減少CPU的資源浪費，而且還可以實現在多個線程間通信，它就是 “等待/通知”（wait/notify）機制。
（2）什么是等待/通知機制
等待/通知機制在生活中比比皆是，比如在就餐時就會出現
廚師和服務員之間的交互要在 “菜品傳遞臺”上，在這期間會有幾個問題：
問題一：廚師做完一道菜的時間不確定，所以廚師將菜品放到“菜品傳遞臺”上的時間也不確定。
問題二：服務員取到菜的時間取決于廚師，所以服務員就有“等待”（wait）的狀態(tài)。
問題三：服務員如何能取到菜呢？這又得取決于廚師，廚師將菜放在“菜品傳遞臺”上，其實就相當于一種通知（notfiy），這時服務員才可以拿到菜并交給就餐者。
問題四：在這個過程中出現了“等待/通知”機制。
（3）等待/通知機制的實現
方法wait()的作用是使當前執(zhí)行代碼的線程進行等待，wait()方法是Object類的方法，該方法用來將當前線程置入“預執(zhí)行隊列”中，并且在wait()所在的代碼行處停止執(zhí)行，直到接到通知或被中斷為止。在調用wait()之前，線程必須獲取該對象的對象級別鎖，即只能在同步方法或同步塊中調用wait()方法。在執(zhí)行wait()方法后，當前線程釋放鎖。在從wait()返回前，線程與其他線程競爭重新獲得鎖。如果調用wait()時沒有持有適當的鎖，則拋出 IllegalMonitorStateException，它是 RuntimeException的一個子類，因此，不需要 try-catch 語句進行捕捉異常。
方法notify()也要在同步方法或同步塊中調用，即在調用前，線程也必須獲取該對象的對象級別鎖。如果調用notify()時沒有持有適當的鎖，也會拋出IllegalMonitorStateException。該方法用來通知那些可能等待該對象的對象鎖的其他線程，如果有多個線程等待，則由線程規(guī)劃器隨機挑選出其中一個呈wait狀態(tài)的線程，對其發(fā)出通知notify，并是它等待獲取該對象的對象鎖。需要說明是：在執(zhí)行notify()方法后，當前線程不會馬上釋放該對象鎖，呈wait狀態(tài)的線程也并不能馬上獲取該對象鎖，要等到執(zhí)行notify()方法的線程將程序執(zhí)行完，也就是退出synchronized代碼塊后，當前線程才會釋放鎖，而呈wait狀態(tài)所在的線程才可以獲取該對象鎖。當第一個獲得了該對象鎖的wait線程運行完畢以后，它會釋放掉該對象鎖，此時如果該對象沒有再次使用notify語句，則幾遍該對象已經空閑，其他wait狀態(tài)等待的線程由于沒有得到該對象的通知，還會繼續(xù)阻塞在wait狀態(tài)，直到這個對象發(fā)出一個notify 或 notifyAll。
總結一下：
wait：使線程停止運行
notify：使停止的線程繼續(xù)運行
驗證1：在調用wait()之前，線程必須獲取該對象的對象級別鎖，即只能在同步方法或同步塊中調用wait()方法。如果調用wait()時沒有持有適當的鎖，則拋出IllegalMonitorStateException。
@Test
public void test1() {
try {
String str = new String("");
str.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}執(zhí)行結果：
驗證2：調用了wait()，線程會在調用wait()所在的代碼行處停止執(zhí)行，直到接到通知或被中斷為止。
@Test
public void test2() {
String lockStr = new String("");
System.out.println("sync 上面");
try {
synchronized (lockStr) {
System.out.println("進入 sync");
lockStr.wait();
System.out.println("wait 下的代碼");
}
System.out.println("sync 下面的代碼");
} catch (InterruptedException e) {
e.printStackTrace();
}
}執(zhí)行結果：
結果分析：
線程執(zhí)行了wait()方法后，程序就停止不前，不繼續(xù)向下運行了。如何使呈等待wait狀態(tài)的線程繼續(xù)運行呢？答案就是使用notify()方法。
@Test
public void test3() {
try {
Object lock = new Object();
ThreadC3A threadC3A = new ThreadC3A(lock);
threadC3A.start();
Thread.sleep(3000);
ThreadC3B threadC3B = new ThreadC3B(lock);
threadC3B.start();
} catch (Exception e) {
e.printStackTrace();
}
}
class ThreadC3A extends Thread {
private Object lock;
public ThreadC3A(Object lock) {
this.lock = lock;
}
@Override
public void run() {
try {
synchronized (lock) {
System.out.println("開始 wait，Time=[" + System.currentTimeMillis() + "]");
lock.wait();
System.out.println("結束 wait，Time=[" + System.currentTimeMillis() + "]");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
class ThreadC3B extends Thread {
private Object lock;
public ThreadC3B(Object lock) {
this.lock = lock;
}
@Override
public void run() {
synchronized (lock) {
System.out.println("開始 notify，Time=[" + System.currentTimeMillis() + "]");
lock.notify();
System.out.println("結束 notify，Time=[" + System.currentTimeMillis() + "]");
}
}
}
執(zhí)行結果：
開始 wait，Time=[1659520582642]
開始 notify，Time=[1659520585652]
結束 notify，Time=[1659520585652]
結束 wait，Time=[1659520585656]
驗證3：notify方法用來通知那些可能等待該對象的對象鎖的其他線程，如果有多個線程等待，則有線程規(guī)劃器隨機挑選出其中一個呈wait狀態(tài)的線程，對其發(fā)出通知notify，并使它等待獲取該對象的對象鎖。
public class TestC5 {
@Test
public void test1() {
Object obj = new Object();
MyArrayList list = new MyArrayList();
ThreadC5B threadC5B = new ThreadC5B(obj, list);
threadC5B.start();
ThreadC5C threadC5C = new ThreadC5C(obj, list);
threadC5C.start();
ThreadC5A threadC5A = new ThreadC5A(obj, list);
threadC5A.start();
while (Thread.activeCount() > 1) {
}
}
}
class ThreadC5A extends Thread {
private Object lock;
private MyArrayList list;
public ThreadC5A(Object lock, MyArrayList list) {
this.lock = lock;
this.list = list;
}
@Override
public void run() {
try {
synchronized (lock) {
for (int i=0; i<10; i++) {
list.add();
System.out.println("ThreadC5A 新增第[" + (i+1) + "]個元素");
if (list.size() == 5) {
lock.notify();
System.out.println("ThreadC5A 發(fā)出通知，通知等待的線程 ThreadC5B 或 ThreadC5C");
}
Thread.sleep(1000);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
class ThreadC5B extends Thread {
private Object lock;
private MyArrayList list;
public ThreadC5B(Object lock, MyArrayList list) {
this.lock = lock;
this.list = list;
}
@Override
public void run() {
try {
while (true) {
synchronized (lock) {
System.out.println("ThreadC5B 等待被通知");
lock.wait();
System.out.println("ThreadC5B 收到通知，退出");
return;
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
class ThreadC5C extends Thread {
private Object lock;
private MyArrayList list;
public ThreadC5C(Object lock, MyArrayList list) {
this.lock = lock;
this.list = list;
}
@Override
public void run() {
try {
while (true) {
synchronized (lock) {
System.out.println("ThreadC5C 等待被通知");
lock.wait();
System.out.println("ThreadC5C 收到通知，退出");
return;
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}執(zhí)行結果：
結果分析：
可以看到處于wait狀態(tài)的ThreadC5B線程被通知到繼續(xù)執(zhí)行，而ThreadC5C線程則一直將處于wait狀態(tài)，無法繼續(xù)執(zhí)行。倘若我們將ThreadC5A線程中的 lock.notify() 改寫為 lock.notifyAll()，則結果就不一樣，如圖所示：
發(fā)現ThreadC5B 和 ThreadC5C線程均獲取到了對象鎖，完成了wait()后面代碼的執(zhí)行。
驗證4：上圖的結果還可以驗證在執(zhí)行notify()方法后，當前線程不會馬上釋放該對象鎖，呈wait狀態(tài)的線程也并不能馬上獲取該對象鎖，要等到執(zhí)行notify()方法的線程將程序執(zhí)行完，也就是退出synchronized代碼塊后，當前線程才會釋放鎖，而呈wait狀態(tài)所在的線程才可以獲取該對象鎖。
結果分析：
可以看出 ThreadC5A 線程在list 長度為5的時候，則通知了 ThreadC5B 和 ThreadC5C 兩個處于wait狀態(tài)的線程，但是 ThreadC5B 和 ThreadC5C 線程并沒有立馬繼續(xù)執(zhí)行，因為此時 ThreadC5A 并沒有釋放對象鎖，而是繼續(xù)執(zhí)行 synchronized的代碼塊，直到退出synchronized代碼塊后，ThreadC5A 才釋放了對象鎖，ThreadC5B 和 ThreadC5C 獲得對象鎖，才得以繼續(xù)執(zhí)行后續(xù)代碼。
到此這篇關于Java使用wait/notify實現線程間通信上篇的文章就介紹到這了,更多相關Java wait/notify內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
Java微信公眾平臺開發(fā)（6） 微信開發(fā)中的token獲取
這篇文章主要為大家詳細介紹了Java微信公眾平臺開發(fā)第六步，微信開發(fā)中的token獲取，具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-04-04
大家好，本篇文章主要講的是Java中的遞歸方法示例介紹，感興趣的同學趕快來看一看吧，對你有幫助的話記得收藏一下，方便下次瀏覽2021-12-12
詳談@Cacheable不起作用的原因:bean未序列化問題
這篇文章主要介紹了@Cacheable不起作用的原因:bean未序列化問題，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2022-01-01
本文主要講述了微服務體系下的?Spring?Cloud?Netflix?套件中?Ribbon?的使用，并結合部分源碼講述了?Ribbon?的底層原理，重點講述了?Ribbon?中是如何獲取服務以及如何判定一個服務是否可用，最后也介紹了?Ribbon?中默認提供的?7?種負載均衡策略，感興趣的朋友一起看看吧2022-04-04
Spring Boot雖然是Spring的衍生物, 但默認情況下Boot是不能直接使用Spring的配置文件的, 我們可以通過兩種方式導入Spring的配置2022-10-10
在日常的開發(fā)中，我們難免會對日期格式化，對日期進行計算，對日期進行校驗，為了避免重復寫這些瑣碎的邏輯，我這里封裝了一個日期工具類，方便以后使用，直接復制代碼到項目中即可使用，需要的可以參考一下2022-10-10
mybatis中映射文件(mapper)中的使用規(guī)則
這篇文章主要介紹了mybatis中映射文件(mapper)中的使用規(guī)則，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-11-11
Java實戰(zhàn)之用Swing實現通訊錄管理系統(tǒng)
今天給大家?guī)淼氖荍ava實戰(zhàn)的相關知識,文章圍繞著Swing實現通訊錄管理系統(tǒng)展開,文中有非常詳細的代碼示例,需要的朋友可以參考下2021-06-06
這篇文章主要介紹了JAVA注解相關知識，文中講解非常詳細，代碼幫助大家更好的理解和學習，感興趣的朋友可以了解下2020-06-06
這篇文章主要介紹了idea工具配置隱藏文件及文件夾方式,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2024-08-08