Java使用wait/notify實現(xiàn)線程間通信上篇

更新時間：2022年12月12日 15:37:07 作者：愛吃南瓜糕的北絡(luò)

wait()和notify()是直接隸屬于Object類,也就是說所有對象都擁有這一對方法,下面這篇文章主要給大家介紹了關(guān)于使用wait/notify實現(xiàn)線程間通信的相關(guān)資料,需要的朋友可以參考下

線程是操作系統(tǒng)中獨立的個體，但這些個體如果不經(jīng)過特殊的處理就不能成為一個整體。線程間的通信就是成為整體的必用方案之一，使用線程間進(jìn)行通信后，系統(tǒng)之間的交互性會更強大，大大提高CPU利用率。

等待/通知機制

（1）不使用等待/通知機制實現(xiàn)線程間通信

樣例代碼如下：

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í)行結(jié)果：

分析：

程序運行后的效果如上圖所示：

雖然 ThreadA 和 ThreadB 實現(xiàn)了通信，但有一個弊端就是，ThreadB 需要不停地通過 while 語句輪詢機制來檢測某一個條件，這樣會浪費CPU資源。

如果輪詢的時間間隔很小，更浪費CPU資源；如果輪詢的時間間隔很大，有可能會取不到想要得到的數(shù)據(jù)。所以就需要有一種機制來實現(xiàn)減少CPU的資源浪費，而且還可以實現(xiàn)在多個線程間通信，它就是 “等待/通知”（wait/notify）機制。

（2）什么是等待/通知機制

等待/通知機制在生活中比比皆是，比如在就餐時就會出現(xiàn)

廚師和服務(wù)員之間的交互要在 “菜品傳遞臺”上，在這期間會有幾個問題：

問題一：廚師做完一道菜的時間不確定，所以廚師將菜品放到“菜品傳遞臺”上的時間也不確定。

問題二：服務(wù)員取到菜的時間取決于廚師，所以服務(wù)員就有“等待”（wait）的狀態(tài)。

問題三：服務(wù)員如何能取到菜呢？這又得取決于廚師，廚師將菜放在“菜品傳遞臺”上，其實就相當(dāng)于一種通知（notfiy），這時服務(wù)員才可以拿到菜并交給就餐者。

問題四：在這個過程中出現(xiàn)了“等待/通知”機制。

（3）等待/通知機制的實現(xiàn)

方法wait()的作用是使當(dāng)前執(zhí)行代碼的線程進(jìn)行等待，wait()方法是Object類的方法，該方法用來將當(dāng)前線程置入“預(yù)執(zhí)行隊列”中，并且在wait()所在的代碼行處停止執(zhí)行，直到接到通知或被中斷為止。在調(diào)用wait()之前，線程必須獲取該對象的對象級別鎖，即只能在同步方法或同步塊中調(diào)用wait()方法。在執(zhí)行wait()方法后，當(dāng)前線程釋放鎖。在從wait()返回前，線程與其他線程競爭重新獲得鎖。如果調(diào)用wait()時沒有持有適當(dāng)?shù)逆i，則拋出 IllegalMonitorStateException，它是 RuntimeException的一個子類，因此，不需要 try-catch 語句進(jìn)行捕捉異常。

方法notify()也要在同步方法或同步塊中調(diào)用，即在調(diào)用前，線程也必須獲取該對象的對象級別鎖。如果調(diào)用notify()時沒有持有適當(dāng)?shù)逆i，也會拋出IllegalMonitorStateException。該方法用來通知那些可能等待該對象的對象鎖的其他線程，如果有多個線程等待，則由線程規(guī)劃器隨機挑選出其中一個呈wait狀態(tài)的線程，對其發(fā)出通知notify，并是它等待獲取該對象的對象鎖。需要說明是：在執(zhí)行notify()方法后，當(dāng)前線程不會馬上釋放該對象鎖，呈wait狀態(tài)的線程也并不能馬上獲取該對象鎖，要等到執(zhí)行notify()方法的線程將程序執(zhí)行完，也就是退出synchronized代碼塊后，當(dāng)前線程才會釋放鎖，而呈wait狀態(tài)所在的線程才可以獲取該對象鎖。當(dāng)?shù)谝粋€獲得了該對象鎖的wait線程運行完畢以后，它會釋放掉該對象鎖，此時如果該對象沒有再次使用notify語句，則幾遍該對象已經(jīng)空閑，其他wait狀態(tài)等待的線程由于沒有得到該對象的通知，還會繼續(xù)阻塞在wait狀態(tài)，直到這個對象發(fā)出一個notify 或 notifyAll。

總結(jié)一下：

wait：使線程停止運行

notify：使停止的線程繼續(xù)運行

驗證1：在調(diào)用wait()之前，線程必須獲取該對象的對象級別鎖，即只能在同步方法或同步塊中調(diào)用wait()方法。如果調(diào)用wait()時沒有持有適當(dāng)?shù)逆i，則拋出IllegalMonitorStateException。

@Test
public void test1() {
    try {
        String str = new String("");
        str.wait();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

執(zhí)行結(jié)果：

驗證2：調(diào)用了wait()，線程會在調(diào)用wait()所在的代碼行處停止執(zhí)行，直到接到通知或被中斷為止。

@Test
public void test2() {
    String lockStr = new String("");
    System.out.println("sync 上面");
    try {
         synchronized (lockStr) {
             System.out.println("進(jìn)入 sync");
             lockStr.wait();
             System.out.println("wait 下的代碼");
         }
         System.out.println("sync 下面的代碼");
     } catch (InterruptedException e) {
         e.printStackTrace();
     }
}

執(zhí)行結(jié)果：

結(jié)果分析：

線程執(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("結(jié)束 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("結(jié)束 notify，Time=[" + System.currentTimeMillis() + "]");
        }
    }
}

執(zhí)行結(jié)果：
開始 wait，Time=[1659520582642]
開始 notify，Time=[1659520585652]
結(jié)束 notify，Time=[1659520585652]
結(jié)束 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í)行結(jié)果：

結(jié)果分析：

可以看到處于wait狀態(tài)的ThreadC5B線程被通知到繼續(xù)執(zhí)行，而ThreadC5C線程則一直將處于wait狀態(tài)，無法繼續(xù)執(zhí)行。倘若我們將ThreadC5A線程中的 lock.notify() 改寫為 lock.notifyAll()，則結(jié)果就不一樣，如圖所示：

發(fā)現(xiàn)ThreadC5B 和 ThreadC5C線程均獲取到了對象鎖，完成了wait()后面代碼的執(zhí)行。

驗證4：上圖的結(jié)果還可以驗證在執(zhí)行notify()方法后，當(dāng)前線程不會馬上釋放該對象鎖，呈wait狀態(tài)的線程也并不能馬上獲取該對象鎖，要等到執(zhí)行notify()方法的線程將程序執(zhí)行完，也就是退出synchronized代碼塊后，當(dāng)前線程才會釋放鎖，而呈wait狀態(tài)所在的線程才可以獲取該對象鎖。

結(jié)果分析：

可以看出 ThreadC5A 線程在list 長度為5的時候，則通知了 ThreadC5B 和 ThreadC5C 兩個處于wait狀態(tài)的線程，但是 ThreadC5B 和 ThreadC5C 線程并沒有立馬繼續(xù)執(zhí)行，因為此時 ThreadC5A 并沒有釋放對象鎖，而是繼續(xù)執(zhí)行 synchronized的代碼塊，直到退出synchronized代碼塊后，ThreadC5A 才釋放了對象鎖，ThreadC5B 和 ThreadC5C 獲得對象鎖，才得以繼續(xù)執(zhí)行后續(xù)代碼。

到此這篇關(guān)于Java使用wait/notify實現(xiàn)線程間通信上篇的文章就介紹到這了,更多相關(guān)Java wait/notify內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: