2. 程式人生 > >執行緒的掛起和喚醒

執行緒的掛起和喚醒

阿新 • • 發佈：2018-11-08
1. 執行緒的掛起和喚醒
      掛起實際上是讓執行緒進入“非可執行”狀態下，在這個狀態下CPU不會分給執行緒時間片，進入這個狀態可以用來暫停一個執行緒的執行；線上程掛起後，可以通過重新喚醒執行緒來使之恢復執行。

掛起的原因可能是如下幾種情況：
     （1）通過呼叫sleep()方法使執行緒進入休眠狀態，執行緒在指定時間內不會執行。
     （2）通過呼叫join()方法使執行緒掛起，使自己等待另一個執行緒的結果，直到另一個執行緒執行完畢為止。

     （3）通過呼叫wait()方法使執行緒掛起，直到執行緒得到了notify()和notifyAll()訊息，執行緒才會進入“可執行”狀態。
     （4）使用suspend掛起執行緒後，可以通過resume方法喚醒執行緒。
      雖然suspend和resume可以很方便地使執行緒掛起和喚醒，但由於使用這兩個方法可能會造成死鎖，因此，這兩個方法被標識為  deprecated（抗議）標記 ，這表明在以後的jdk版本中這兩個方法可能被刪除，所以儘量不要使用這兩個方法來操作執行緒。


      呼叫sleep()、yield()、suspend()的時候並沒有被釋放鎖

        yield() 使得執行緒放棄當前分得的 CPU 時間，但是不使執行緒阻塞，即執行緒仍處於可執行狀態，隨時可能再次分得 CPU 時間。呼叫 yield() 的效果等價於排程程式認為該執行緒已執行了足夠的時間從而轉到另一個執行緒

      呼叫wait()的時候釋放當前物件的鎖

      wait()方法表示，放棄當前對資源的佔有權，一直等到有執行緒通知，才會執行後面的程式碼。

      notify()方法表示，當前的執行緒已經放棄對資源的佔有，通知等待的執行緒來獲得對資源的佔有權，但是隻有一個執行緒能夠從wait狀態中恢復，然後繼續執行wait()後面的語句。

      notifyAll()方法表示，當前的執行緒已經放棄對資源的佔有，通知所有的等待執行緒從wait()方法後的語句開始執行。

       當第一個執行緒執行完畢以後釋放物件上的鎖此時如果該物件沒有再次使用notify語句，則即便該物件已經空閒，其他wait狀態等待的執行緒由於沒有得到該物件的通知，繼續處在wait狀態，直到這個物件發出一個notify或notifyAll，它們等待的是被notify或notifyAll，而不是鎖。 


2.等待和鎖實現資源競爭
      等待機制與鎖機制是密切關聯的，對於需要競爭的資源，首先用synchronized確保這段程式碼只能一個執行緒執行，可以再設定一個標誌位condition判斷該資源是否準備好，如果沒有，則該執行緒釋放鎖，自己進入等待狀態，直到接收到notify，程式從wait處繼續向下執行。
  1. synchronized(obj) {
  2. 　　while(!condition) {
  3. 　　 obj.wait();
  4. 　　}
  5. 　　obj.doSomething();
  6. }
以上程式表示只有一個執行緒A獲得了obj鎖後，發現條件condition不滿足，無法繼續下一處理，於是執行緒A釋放該鎖，進入wait()。

      在另一執行緒B中，如果B更改了某些條件，使得執行緒A的condition條件滿足了，就可以喚醒執行緒A：
  1. synchronized(obj) {
  2. 　condition = true;
  3. 　obj.notify();
  4. }
需要注意的是：
　　# 呼叫obj的wait(), notify()方法前，必須獲得obj鎖，也就是必須寫在synchronized(obj) {...} 程式碼段內。
　　# 呼叫obj.wait()後，執行緒A就釋放了obj的鎖，否則執行緒B無法獲得obj鎖，也就無法在synchronized(obj) {...} 程式碼段內喚醒A。
　　# 當obj.wait()方法返回後，執行緒A需要再次獲得obj鎖，才能繼續執行。
　　#  如果A1,A2,A3都在obj.wait()，則B呼叫obj.notify()只能喚醒A1,A2,A3中的一個(具體哪一個由JVM決定) 。
　　# obj.notifyAll()則能全部喚醒A1,A2,A3，但是要繼續執行obj.wait()的下一條語句，必須獲得obj鎖，因此，A1,A2,A3只有一個有機會獲得鎖繼續執行，例如A1，其餘的需要等待A1釋放obj鎖之後才能繼續執行。
　　# 當B呼叫obj.notify/notifyAll的時候，B正持有obj鎖，因此，A1,A2,A3雖被喚醒，但是仍無法獲得obj鎖。直到B退出synchronized塊，釋放obj鎖後，A1,A2,A3中的一個才有機會獲得鎖繼續執行。


例1：單個執行緒對多個執行緒的喚醒
      假設只有一個Game物件，但有3個人要玩，由於只有一個遊戲資源，必須必然依次玩。
  1. /**
  2.  * 玩遊戲的人.
  3.  * @version V1.0 ,2011-4-8
  4.  * @author xiahui
  5.  */
  6. public class Player implements Runnable {
  7.     private final int id;
  8.     private Game game;

  10.     public Player(int id, Game game) {
  11.         this.id = id;
  12.         this.game = game;
  13.     }


  16.     public String toString() {
  17.         return "Athlete<" + id + ">";
  18.     }

  20.     public int hashCode() {
  21.         return new Integer(id).hashCode();
  22.     }
  23.     
  24.     public void playGame() throws InterruptedException{
  25.         System.out.println(this.toString() + " ready!");
  26.         game.play(this);
  27.     }

  29.     public void run() {
  30.         try {
  31.             playGame();
  32.         } catch (InterruptedException e) {
  33.             System.out.println(this + " quit the game");
  34.         }
  35.     }
  36. }
遊戲類，只例項化一個
  1. import java.util.HashSet;
  2. import java.util.Iterator;
  3. import java.util.Set;

  5. /**
  6.  * 遊戲類.
  7.  * @version V1.0 ,2011-4-8
  8.  * @author xiahui
  9.  */
  10. public class Game implements Runnable {
  11.     private boolean start = false;

  13.     public void play(Player player) throws InterruptedException {
  14.         synchronized (this) {
  15.             while (!start)
  16.                 wait();
  17.             if (start)
  18.                 System.out.println(player + " have played!");
  19.         }
  20.     }

  22.     //通知所有玩家
  23.     public synchronized void beginStart() {
  24.         start = true;
  25.         notifyAll();
  26.     }

  28.     public void run() {
  29.         start = false;
  30.         System.out.println("Ready......");
  31.         System.out.println("Ready......");
  32.         System.out.println("game start");
  33.         beginStart();//通知所有玩家遊戲準備好了
  34.     }

  36.     public static void main(String[] args) {
  37.         Set<Player> players = new HashSet<Player>();
  38.         //例項化一個遊戲
  39.         Game game = new Game();
  40.         
  41.         //例項化3個玩家
  42.         for (int i = 0; i < 3; i++)
  43.             players.add(new Player(i, game));
  44.         
  45.         //啟動3個玩家
  46.         Iterator<Player> iter = players.iterator();
  47.         while (iter.hasNext())
  48.             new Thread(iter.next()).start();
  49.         Thread.sleep(100);
  50.         
  51.         //遊戲啟動
  52.         new Thread(game).start();
  53.     }
  54. }
程式先啟動玩家，三個玩家競爭玩遊戲，但只能有一個進入play，其他二個等待，進入的玩家發現遊戲未準備好，所以wait，等遊戲準備好後，依次玩。
執行結果
  1. Athlete<0> ready!
  2. Athlete<1> ready!
  3. Athlete<2> ready!
  4. Ready......
  5. Ready......
  6. game start
  7. Athlete<2> have played!
  8. Athlete<1> have played!
  9. Athlete<0> have played!

3.一次喚醒一個執行緒
      一次喚醒所有玩家，但只有一個玩家能玩，不如一個一個喚醒
將上面的程式碼修改如下
  1.     public void play(Player player) throws InterruptedException {
  2.         synchronized (this) {
  3.             while (!start)
  4.                 wait();
  5.             if (start){
  6.                 System.out.println(player + " have played!");
  7.                 notify();//玩完後，通知下一個玩家來玩
  8.             }
  9.         }
  10.     }
  11.     //通知一個玩家
  12.     public synchronized void beginStart() {
  13.         start = true;
  14.         notify();
  15.     }

4.suspend掛起
      該方法已不建議使用，例子如下
例2：suspend方法進行掛起和喚醒
  1. /**
  2.  * suspend方法進行掛起和喚醒.
  3.  * @version V1.0 ,2011-3-27 
  4.  * @author xiahui
  5.  */
  6. public class SuspendThread implements Runnable{
  7.     public void run() {
  8.         try {
  9.             Thread.sleep(10);
  10.         } catch (Exception e) {
  11.             System.out.println(e);
  12.         }
  13.         for (int i = 0; i <= 1; i ) {
  14.             System.out.println(Thread.currentThread().getName() ":" i);
  15.         }
  16.     }

  18.     public static void main(String args[]) throws Exception {
  19.         Thread th1 = new Thread(new SuspendThread(),"thread1");
  20.         Thread th2 = new Thread(new SuspendThread(),"thread2");
  21.         System.out.println("Starting " th1.getName() "...");
  22.         th1.start();
  23.         System.out.println("Suspending " th1.getName() "...");
  24.         //Suspend the thread.
  25.         th1.suspend();
  26.         th2.start();
  27.         th2.join();
  28.         // Resume the thread.
  29.         th1.resume();
  30.     }
  31. }
執行結果
  1. Starting thread1...
  2. Suspending thread1...
  3. thread2:0
  4. thread2:1
  5. thread1:0
  6. thread1:1
注意：
      如果註釋掉//th2.join();則thread2執行後，主執行緒會直接執行thread1的resume，執行結果可能會是
  1. Starting thread1...
  2. Suspending thread1...
  3. thread1:0
  4. thread1:1
  5. thread2:0
  6. thread2:1

多執行緒爭取一個物件，某些情況下， 可以替代static靜態變數


import java.util.*;

class Widget...{}
class WidgetMaker extends Thread...{
    List<Widget> finishedWidgets=new ArrayList<Widget>();
    public void run()...{
        try...{
            while(true)...{
                Thread.sleep(5000);//act busy
                Widget w=new Widget();
                //也就是說需要5秒鐘才能新產生一個Widget，這決定了一定要用notify而不是notifyAll
                //因為上面兩行程式碼不是同步的，如果用notifyAll則所有執行緒都企圖衝出wait狀態
                //第一個執行緒得到了鎖，並取走了Widget（這個過程的時間小於5秒，新的Widget還沒有生成）
                //並且解開了鎖，然後第二個執行緒獲得鎖(因為用了notifyAll其他執行緒不再等待notify語句
                //，而是等待finishedWidgets上的鎖，一旦鎖放開了，他們就會競爭執行)，執行
                //finishedWidgets.remove(0)，但是由於finishedWidgets現在還是空的，
                //於是產生異常
                //***********這就是為什麼下面的那一句不能用notifyAll而是要用notify
                                
                synchronized(finishedWidgets)...{
                    finishedWidgets.add(w);
                    finishedWidgets.notify(); //這裡只能是notify而不能是notifyAll
                }
            }
        }
        catch(InterruptedException e)...{}
    }
    
    public Widget waitForWidget()...{
        synchronized(finishedWidgets)...{
            if(finishedWidgets.size()==0)...{
                try...{
                    finishedWidgets.wait();
                }
                catch(InterruptedException e)
                ...{}
            }
            return finishedWidgets.remove(0);
        }
    }
}
public class WidgetUser extends Thread...{
    private WidgetMaker maker;
    public WidgetUser(String name,WidgetMaker maker)...{
        super(name);
        this.maker=maker;
    }
    public void run()...{
        Widget w=maker.waitForWidget();
        System.out.println(getName()+"got a widget");
    }
   

    public static void main(String[] args) ...{
        WidgetMaker maker=new WidgetMaker();
        maker.start();
        new WidgetUser("Lenny",maker).start();
        new WidgetUser("Moe",maker).start();
        new WidgetUser("Curly",maker).start();

    }

}



相關推薦

LockSupport實現執行緒掛起和喚醒——深入淺出原碼分析

面試題 （1）LockSupport比Object的wait/notify有兩大優勢，分別是什麼？ （2）LockS

執行緒掛起和恢復的幾種方法

執行緒掛起和恢復方法（1）：sleep()方法 此種方法比較簡單，哪個執行緒需要掛起就在哪個執行緒中直接呼叫：Thread.sleep(掛起的毫秒數); 執行緒掛起和恢復方式（2）：join()方法 在實現多執行緒的兩種方法這篇博文中值說明了Threa

根據Linux 執行緒掛起與喚醒原理，實現Sleep的暫停與繼續

在呼叫pthread_cond_wait()前必須由本執行緒加鎖（pthread_mutex_lock()），而在更新條件等待佇列以前，mutex保持鎖定狀態，並在執行緒掛起進入等待前解鎖。在條件滿足從而離開pthread_cond_wait()之前，mutex將被重新加鎖，以與進入pthread_cond_

執行緒的掛起和喚醒

1. 執行緒的掛起和喚醒       掛起實際上是讓執行緒進入“非可執行”狀態下，在這個狀態下CPU不會分給執行緒時間片，進入這個狀態可以用來暫停一個執行緒的執行；線上程掛起後，可以通過重新喚醒執行緒來使之恢復執行。 掛起的原因可

Java併發程式設計（3）：執行緒掛起、恢復與終止的正確方法（含程式碼）

JAVA大資料中高階架構 2018-11-06 14:24:56掛起和恢復執行緒Thread 的API中包含兩個被淘汰的方法，它們用於臨時掛起和重啟某個執行緒，這些方法已經被淘汰，因為它們是不安全的，不穩定的。如果在不合適的時候掛起執行緒（比如，鎖定共享資源時），此時便可能會發生死鎖條件——其他執行緒在等待該

關於執行緒掛起

解釋1：本來執行緒是佔用cpu資源的，但是如果掛起的話，作業系統就不給這個現成分配cpu資源，除非以後再恢復，所以執行緒掛起的作用就是節省cpu資源   解釋2：你有一件很漂亮的衣服，你只想在約會的時候穿它，最近沒人約你，你只好將它掛起來（這叫掛起suspend）。。。直到有一天有

哪幾種方式可用來實現執行緒間通知和喚醒

從這三個方法的文字描述可以知道以下幾點資訊： 1）wait()、notify()和notifyAll()方法是本地方法，並且為final方法，無法被重寫。 2）呼叫某個物件的wait()方法能讓當前執行緒阻塞，並且當前執行緒必須擁有此物件的monitor（即鎖） 3）呼叫某個物件的notify()方

【Qt多執行緒之執行緒的等待和喚醒】QWaitCondition

QWatiCondition的成員函式 ·QWaitCondition() ·~QWaitCondition() ·bool wait ( QMutex * mutex, unsigned long time = ULONG_MAX ) ·vo

執行緒通訊-等待和喚醒機制和鎖（Lock）機制

生產者和消費者案例分析： 經典的生產者和消費者案例(Producer/Consumer):      分析案例:               1):生產者和消費者應該操作共享的資源(實現方式來做).               2):使用一個或多個執行緒來表示生產者(Pro

FTP讀取遠端檔案&解決使用FTPClient類時執行緒掛起的問題

一、首先介紹FTP的基本知識（會的直接跳過）1.什麼是FTPFTP是File Transfer Protocol（檔案傳輸協議）的英文簡稱，而中文簡稱為“文傳協議”。用於Internet上的控制檔案的雙向傳輸。同時，它也是一個應用程式（Application）。說白了，就是檔

Java併發程式設計之三：執行緒掛起、恢復與終止的正確方法

出處：http://blog.csdn.NET/ns_code/article/details/17095733 掛起和恢復執行緒 Thread 的API中包含兩個被淘汰的方法，它們用於臨時掛起和重啟某個執行緒，這些方法已經被淘汰，因為它們是不安全的，不穩定的。如果

第二部分 執行緒的等待和喚醒

從這個圖中可以看出，等待狀態是一種特殊的狀態。使執行緒陷入等待實際上是暫時剝奪執行緒當前擁有的CPU時間片和獲取CPU時間片的資格，使其返回到就緒狀態。除非被喚醒，否則等待時間已滿，該執行緒將一

USB的掛起和喚醒 (Suspend and Resume)

USB協議的第9章講到USB可見裝置狀態[Universal Serial Bus Specification, Section 9.1.1, Pg 239]，分為連線(Attached)，上電(Powered)，預設(Default)，地址(Address)，配置(Co

MFC執行緒的掛起、喚醒和終止

1、建立一個基於MFC的基本對話方塊，命名為ThreadManage 2、在對話方塊視窗建立五個按鈕和一個靜態文字和一個進度條 _______________________________________ |    _____________________________

【.NET】執行緒的暫停和掛起

C#中使得多執行緒暫停掛起的方法有多種，但各有不同。我逐個說明： sleep方法是個靜態方法，由thread類來呼叫。它只能暫停當前執行緒，不能暫停其他執行緒。它接受的引數指名這個執行緒需要休眠多少時間。 suspend方法是普通方法，由物件呼叫，他不但能夠終止

Linux 3.15核心將啟用非同步執行緒來減少掛起和恢復時間

Phoronix近期報道：Linux 3.15核心版本，預計將於2014年中期公佈，該版本“將有大量的ACPI和電源管理的更新”，並允許基於Linux的計算機掛起和恢復速度更快。 Linux的最新的穩定版本是3.13.6版本，Linux 3.14即將釋出，同時Linux 3.15的合併視窗即將開啟。

VC執行緒的掛起及喚醒

執行緒的掛起是指暫停執行緒的執行，讓其進入系統的掛起執行緒佇列，並擺脫系統排程執行緒的排程。喚醒執行緒是指將被掛起的執行緒從掛起佇列移到系統的就緒佇列，等待系統的排程，進而再次執行。 在MFC中可以使用CWinThread 類的SuspendThread 成員函式掛起

關於執行緒的停止和掛起

在用執行緒的時候經常要啟動和掛起，原來d7的時候可以用resume和suspend(但是，建議不要用這2個方法，因為這2個方法在作業系統層面會造成死鎖)，現在版本的TThread裡已經把這2個方法宣告為deprecated(我用的是xe2,具體不知道從哪個版本起)。原來在D

Linux下執行緒的掛起和恢復

POSIX的Linux作業系統沒有提供執行緒掛起和恢復的例程，在網上找了找，看到一個老外寫的程式，感覺想法不錯，放在這裡大家分享一下。理論上應該可以實現，不過我沒有試，給大家提供一個參考。 （在讀取快取裡的資料時，當快取中沒有資料最好把執行緒掛起） void CPrcThread ::suspend()  {

java掛起和恢復執行緒的api為何廢棄

Thread 的API中包含兩個被淘汰的方法，它們用於臨時掛起和重啟某個執行緒，這些方法已經被淘汰，因為它們是不安全的，不穩定的。如果在不合適的時候掛起執行緒（比如，鎖定共享資源時），此時便可能會發生