2. 程式人生 > >java中yield(),sleep()以及wait()的區別(修正版)(轉帖)

java中yield(),sleep()以及wait()的區別(修正版)(轉帖)

阿新 • • 發佈：2019-02-07

往往混淆了這三個函式的使用。

從作業系統的角度講，os會維護一個ready queue（就緒的執行緒佇列）。並且在某一時刻cpu只為ready queue中位於佇列頭部的執行緒服務。 但是當前正在被服務的執行緒可能覺得cpu的服務質量不夠好，於是提前退出，這就是yield。 或者當前正在被服務的執行緒需要睡一會，醒來後繼續被服務，這就是sleep。 

sleep方法不推薦使用，可用wait。 執行緒退出最好自己實現，在執行狀態中一直檢驗一個狀態，如果這個狀態為真，就一直執行，如果外界更改了這個狀態變數，那麼執行緒就停止執行。

sleep()使當前執行緒進入停滯狀態，所以執行sleep()的執行緒在指定的時間內肯定不會執行；yield()只是使當前執行緒重新回到可執行狀態，所以執行yield()的執行緒有可能在進入到可執行狀態後馬上又被執行。 sleep()可使優先順序低的執行緒得到執行的機會，當然也可以讓同優先順序和高優先順序的執行緒有執行的機會；yield()只能使同優先順序的執行緒有執行的機會。

當呼叫wait()後，執行緒會釋放掉它所佔有的“鎖標誌”，從而使執行緒所在物件中的其它synchronized資料可被別的執行緒使用。

waite()和notify()因為會對物件的“鎖標誌”進行操作，所以它們必須在synchronized函式或synchronized　block中進行呼叫。如果在non-synchronized函式或non-synchronized　block中進行呼叫，雖然能編譯通過，但在執行時會發生IllegalMonitorStateException的異常。

徹底明白多執行緒通訊機制：

執行緒間的通訊 1.    執行緒的幾種狀態 執行緒有四種狀態，任何一個執行緒肯定處於這四種狀態中的一種：

1)    產生（New）：執行緒物件已經產生，但尚未被啟動，所以無法執行。如通過new產生了一個執行緒物件後沒對它呼叫start()函式之前。

2)    可執行（Runnable）：每個支援多執行緒的系統都有一個排程器，排程器會從執行緒池中選擇一個執行緒並啟動它。當一個執行緒處於可執行狀態時，表示它可能正處於執行緒池中等待排排程器啟動它；也可能它已正在執行。如執行了一個執行緒物件的start()方法後，執行緒就處於可執行狀態，但顯而易見的是此時執行緒不一定正在執行中。

3)    死亡（Dead）：當一個執行緒正常結束，它便處於死亡狀態。如一個執行緒的run()函式執行完畢後執行緒就進入死亡狀態。 4)    停滯（Blocked）：當一個執行緒處於停滯狀態時，系統排程器就會忽略它，不對它進行排程。當處於停滯狀態的執行緒重新回到可執行狀態時，它有可能重新執行。如通過對一個執行緒呼叫wait()函式後，執行緒就進入停滯狀態，只有當再次對該執行緒呼叫notify或notifyAll後它才能再次回到可執行狀態。

2.    class　Thread下的常用函式函式 2.1    suspend()、resume() 1)    通過suspend()函式，可使執行緒進入停滯狀態。通過suspend()使執行緒進入停滯狀態後，除非收到resume()訊息，否則該執行緒不會變回可執行狀態。 2)    當呼叫suspend()函式後，執行緒不會釋放它的“鎖標誌”。 例11： 

  1. publicclass MyTest {   
  2. publicstaticvoid main(String[] args) {   
  3.     TestThreadMethod t1 = new TestThreadMethod("t1");   
  4.     TestThreadMethod t2 = new TestThreadMethod("t2");   
  5.     t1.start();// （5）
  6. // t1.start(); //（3）
  7.     t2.start();// （4）
  8.   }   
  9. }   
  10. class TestThreadMethod extends Thread {   
  11. publicstaticint shareVar = 0;   
  12. public TestThreadMethod(String name) {   
  13. super(name);   
  14.   }   
  15. publicsynchronizedvoid run() {   
  16. if (shareVar == 0) {   
  17. for (int i = 0; i < 5; i++) {   
  18.         shareVar++;   
  19. if (shareVar == 5) {   
  20. this.suspend();// （1）
  21.         }   
  22.       }   
  23.     } else {   
  24.       System.out.print(Thread.currentThread().getName());   
  25.       System.out.println(" shareVar = " + shareVar);   
  26. this.resume();// （2）
  27.     }   
  28.   }   
  29. }   
 

public class MyTest {

  public static void main(String[] args) {

    TestThreadMethod t1 = new TestThreadMethod("t1");

    TestThreadMethod t2 = new TestThreadMethod("t2");

    t1.start();// （5）

    // t1.start(); //（3）

    t2.start();// （4）

  }

}

class TestThreadMethod extends Thread {

  public static int shareVar = 0;

  public TestThreadMethod(String name) {

    super(name);

  }

  public synchronized void run() {

    if (shareVar == 0) {

      for (int i = 0; i < 5; i++) {

        shareVar++;

        if (shareVar == 5) {

          this.suspend();// （1）

        }

      }

    } else {

      System.out.print(Thread.currentThread().getName());

      System.out.println(" shareVar = " + shareVar);

      this.resume();// （2）

    }

  }

}

執行結果為：

t2 shareVar = 5 i.    當代碼（5）的t1所產生的執行緒執行到程式碼（1）處時，該執行緒進入停滯狀態。然後排程器從執行緒池中喚起程式碼（4）的t2所產生的執行緒，此時shareVar值不為0，所以執行else中的語句。 ii.    也許你會問，那執行程式碼（2）後為什麼不會使t1進入可執行狀態呢？正如前面所說，t1和t2是兩個不同物件的執行緒，而程式碼（1）和（2）都只對當前物件進行操作，所以t1所產生的執行緒執行程式碼（1）的結果是物件t1的當前執行緒進入停滯狀態；而t2所產生的執行緒執行程式碼（2）的結果是把物件t2中的所有處於停滯狀態的執行緒調回到可執行狀態。 iii.    那現在把程式碼（4）註釋掉，並去掉程式碼（3）的註釋，是不是就能使t1重新回到可執行狀態呢？執行結果是什麼也不輸出。為什麼會這樣呢？也許你會認為，當代碼（5）所產生的執行緒執行到程式碼（1）時，它進入停滯狀態；而程式碼（3）所產生的執行緒和程式碼（5）所產生的執行緒是屬於同一個物件的，那麼就當程式碼（3）所產生的執行緒執行到程式碼（2）時，就可使程式碼（5）所產生的執行緒執行回到可執行狀態。但是要清楚，suspend()函式只是讓當前執行緒進入停滯狀態，但並不釋放當前執行緒所獲得的“鎖標誌”。所以當代碼（5）所產生的執行緒進入停滯狀態時，程式碼（3）所產生的執行緒仍不能啟動，因為當前物件的“鎖標誌”仍被程式碼（5）所產生的執行緒佔有。

2.2     sleep() 1)    sleep ()函式有一個引數，通過引數可使執行緒在指定的時間內進入停滯狀態，當指定的時間過後，執行緒則自動進入可執行狀態。 2)    當呼叫sleep ()函式後，執行緒不會釋放它的“鎖標誌”。 例12：

  1. class TestThreadMethod extends Thread {   
  2. publicstaticint shareVar = 0;   
  3. public TestThreadMethod(String name) {   
  4. super(name);   
  5.   }   
  6. publicsynchronizedvoid run() {   
  7. for (int i = 0; i < 3; i++) {   
  8.       System.out.print(Thread.currentThread().getName());   
  9.       System.out.println(" : " + i);   
  10. try {   
  11.         Thread.sleep(100);// （4）
  12.       } catch (InterruptedException e) {   
  13.         System.out.println("Interrupted");   
  14.       }   
  15.     }   
  16.   }   
  17. }   
  18. publicclass MyTest {   
  19. publicstaticvoid main(String[] args) {   
  20.     TestThreadMethod t1 = new TestThreadMethod("t1");   
  21.     TestThreadMethod t2 = new TestThreadMethod("t2");   
  22.     t1.start(); // (1)
  23.     t1.start(); // (2)
  24. // new Thread(t1).start();// （4）
  25. // new Thread(t1).start();// （5）
  26. // new Thread(t2).start(); （3）t2.start();
  27.   }   
  28. }   
 

class TestThreadMethod extends Thread {

  public static int shareVar = 0;

  public TestThreadMethod(String name) {

    super(name);

  }

  public synchronized void run() {

    for (int i = 0; i < 3; i++) {

      System.out.print(Thread.currentThread().getName());

      System.out.println(" : " + i);

      try {

        Thread.sleep(100);// （4）

      } catch (InterruptedException e) {

        System.out.println("Interrupted");

      }

    }

  }

}

public class MyTest {

  public static void main(String[] args) {

    TestThreadMethod t1 = new TestThreadMethod("t1");

    TestThreadMethod t2 = new TestThreadMethod("t2");

    t1.start(); // (1)

    t1.start(); // (2)

    // new Thread(t1).start();// （4）

    // new Thread(t1).start();// （5）

    // new Thread(t2).start(); （3）t2.start();

  }

}

執行結果為：

引用: Exception in thread "main" java.lang.IllegalThreadStateException t1 : 0  at java.lang.Thread.start(Unknown Source)  at MyTest.main(MyTest.java:26) t1 : 1 t1 : 2

可見，對於同一個物件直接啟動2次會出現異常 我們將(1)和(2)註釋掉，改成 (4)和(5)的程式碼，則執行結果為：

引用: Thread-0 : 0 Thread-0 : 1 Thread-0 : 2 Thread-1 : 0 Thread-1 : 1 Thread-1 : 2

由結果可證明，雖然在run()中執行了sleep()，但是它不會釋放物件的“鎖標誌”，所以除非程式碼(1)的執行緒執行完run()函式並釋放物件的“鎖標誌”，否則程式碼（2）的執行緒永遠不會執行。

如果把程式碼（2）註釋掉，並去掉程式碼（3）的註釋，結果將變為：

引用: Thread-0 : 0 Thread-1 : 0 Thread-0 : 1 Thread-1 : 1 Thread-1 : 2 Thread-0 : 2

由於t1和t2是兩個物件的執行緒，所以當執行緒t1通過sleep()進入停滯時，排程器會從執行緒池中呼叫其它的可執行執行緒，從而t2執行緒被啟動。

例13：

  1. class TestThreadMethod extends Thread {   
  2. publicstaticint shareVar = 0;   
  3. public TestThreadMethod(String name) {   
  4. super(name);   
  5.   }   
  6. publicsynchronizedvoid run() {   
  7. for (int i = 0; i < 5; i++) {   
  8.       System.out.print(Thread.currentThread().getName());   
  9.       System.out.println(" : " + i);   
  10. try {   
  11. if (Thread.currentThread().getName().equals("t1"))   
  12.           Thread.sleep(200);   
  13. else
  14.           Thread.sleep(100);   
  15.       } catch (InterruptedException e) {   
  16.         System.out.println("Interrupted");   
  17.       }   
  18.     }   
  19.   }   
  20. }   
  21. publicclass MyTest {   
  22. publicstaticvoid main(String[] args) {   
  23.     TestThreadMethod t1 = new TestThreadMethod("t1");   
  24.     TestThreadMethod t2 = new TestThreadMethod("t2");   
  25.     t1.start();   
  26. // t1.start();
  27.     t2.start();   
  28.   }   
  29. }   
 

class TestThreadMethod extends Thread {

  public static int shareVar = 0;

  public TestThreadMethod(String name) {

    super(name);

  }

  public synchronized void run() {

    for (int i = 0; i < 5; i++) {

      System.out.print(Thread.currentThread().getName());

      System.out.println(" : " + i);

      try {

        if (Thread.currentThread().getName().equals("t1"))

          Thread.sleep(200);

        else

          Thread.sleep(100);

      } catch (InterruptedException e) {

        System.out.println("Interrupted");

      }

    }

  }

}

public class MyTest {

  public static void main(String[] args) {

    TestThreadMethod t1 = new TestThreadMethod("t1");

    TestThreadMethod t2 = new TestThreadMethod("t2");

    t1.start();

    // t1.start();

    t2.start();

  }

}

執行結果為：

引用: t1 : 0 t2 : 0 t2 : 1 t1 : 1 t2 : 2 t2 : 3 t1 : 2 t2 : 4 t1 : 3 t1 : 4

由於執行緒t1呼叫了sleep(200)，而執行緒t2呼叫了sleep(100)，所以執行緒t2處於停滯狀態的時間是執行緒t1的一半，從從結果反映出來的就是執行緒t2列印兩倍次執行緒t1才打印一次。

2.3    yield() 1)    通過yield ()函式，可使執行緒進入可執行狀態，排程器從可執行狀態的執行緒中重新進行排程。所以呼叫了yield()的函式也有可能馬上被執行。 2)    當呼叫yield ()函式後，執行緒不會釋放它的“鎖標誌”。 例14：

  1. class TestThreadMethod extends Thread {   
  2. publicstaticint shareVar = 0;   
  3. public TestThreadMethod(String name) {   
  4. super(name);   
  5.   }   
  6. publicsynchronizedvoid run() {   
  7. for (int i = 0; i < 4; i++) {   
  8.       System.out.println(Thread.currentThread().getName() + " : " + i);   
  9.       Thread.yield();   
  10.     }   
  11.   }   
  12. }   
  13. publicclass MyTest {   
  14. publicstaticvoid main(String[] args) {   
  15.     TestThreadMethod t1 = new TestThreadMethod("t1");   
  16.     TestThreadMethod t2 = new TestThreadMethod("t2");   
  17. new Thread(t1).start();   
  18. new Thread(t1).start();// （1）
  19. // new Thread(t2).start(); //（2）
  20.   }   
  21. }   
 

class TestThreadMethod extends Thread {

  public static int shareVar = 0;

  public TestThreadMethod(String name) {

    super(name);

  }

  public synchronized void run() {

    for (int i = 0; i < 4; i++) {

      System.out.println(Thread.currentThread().getName() + " : " + i);

      Thread.yield();

    }

  }

}

public class MyTest {

  public static void main(String[] args) {

    TestThreadMethod t1 = new TestThreadMethod("t1");

    TestThreadMethod t2 = new TestThreadMethod("t2");

    new Thread(t1).start();

    new Thread(t1).start();// （1）

    // new Thread(t2).start(); //（2）

  }

}

執行結果為：

引用: Thread-0 : 0 Thread-0 : 1 Thread-0 : 2 Thread-0 : 3 Thread-1 : 0 Thread-1 : 1 Thread-1 : 2 Thread-1 : 3

從結果可知呼叫yield()時並不會釋放物件的“鎖標誌”。  如果把程式碼（1）註釋掉，並去掉程式碼（2）的註釋，結果為：

引用: Thread-0 : 0 Thread-1 : 0 Thread-0 : 1 Thread-1 : 1 Thread-0 : 2 Thread-1 : 2 Thread-0 : 3 Thread-1 : 3

從結果可知，雖然t1執行緒呼叫了yield()，但它馬上又被執行了。 2.4    sleep()和yield()的區別 1)    sleep()使當前執行緒進入停滯狀態，所以執行sleep()的執行緒在指定的時間內肯定不會執行；yield()只是使當前執行緒重新回到可執行狀態，所以執行yield()的執行緒有可能在進入到可執行狀態後馬上又被執行。 2)    sleep()可使優先順序低的執行緒得到執行的機會，當然也可以讓同優先順序和高優先順序的執行緒有執行的機會；yield()只能使同優先順序的執行緒有執行的機會。 例15：

  1. class TestThreadMethod extends Thread {   
  2. publicstaticint shareVar = 0;   
  3. public TestThreadMethod(String name) {   
  4. super(name);   
  5.   }   
  6. publicvoid run() {   
  7. for (int i = 0; i < 4; i++) {   
  8.       System.out.println(Thread.currentThread().getName() + " : " + i);   
  9. // Thread.yield(); （1）
  10. /* （2） */
  11. try {   
  12.         Thread.sleep(300);   
  13.       } catch (InterruptedException e) {   
  14.         System.out.println("Interrupted");   
  15.       }   
  16.     }   
  17.   }   
  18. }   
  19. publicclass MyTest {   
  20. publicstaticvoid main(String[] args) {   
  21.     TestThreadMethod t1 = new TestThreadMethod("t1");   
  22.     TestThreadMethod t2 = new TestThreadMethod("t2");   
  23.     t1.setPriority(Thread.MAX_PRIORITY);   
  24.     t2.setPriority(Thread.MIN_PRIORITY);   
  25.     t1.start();   
  26.     t2.start();   
  27.   }   
  28. }   
 

class TestThreadMethod extends Thread {

  public static int shareVar = 0;

  public TestThreadMethod(String name) {

    super(name);

  }

  public void run() {

    for (int i = 0; i < 4; i++) {

      System.out.println(Thread.currentThread().getName() + " : " + i);

      // Thread.yield(); （1）

      /* （2） */

      try {

        Thread.sleep(300);

      } catch (InterruptedException e) {

        System.out.println("Interrupted");

      }

    }

  }

}

public class MyTest {

  public static void main(String[] args) {

    TestThreadMethod t1 = new TestThreadMethod("t1");

    TestThreadMethod t2 = new TestThreadMethod("t2");

    t1.setPriority(Thread.MAX_PRIORITY);

    t2.setPriority(Thread.MIN_PRIORITY);

    t1.start();

    t2.start();

  }

}

執行結果為：

引用: t1 : 0 t2 : 0 t1 : 1 t2 : 1 t1 : 2 t2 : 2 t1 : 3 t2 : 3

由結果可見，通過sleep()可使優先順序較低的執行緒有執行的機會。註釋掉程式碼（2），並去掉程式碼（1）的註釋，結果為：

引用: t1 : 0 t1 : 1 t2 : 0 t1 : 2 t1 : 3 t2 : 1 t2 : 2 t2 : 3

可見，呼叫yield()，不同優先順序的執行緒永遠不會得到執行機會。 2.5    join() 使呼叫join()的執行緒執行完畢後才能執行其它執行緒，在一定意義上，它可以實現同步的功能。 例16：

  1. class TestThreadMethod extends Thread {   
  2. publicstaticint shareVar = 0;   
  3. public TestThreadMethod(String name) {   
  4. super(name);   
  5.   }   
  6. publicvoid run() {   
  7. for (int i = 0; i < 4; i++) {   
  8.       System.out.println(" " + i);   
  9. try {   
  10.         Thread.sleep(300);   
  11.       } catch (InterruptedException e) {   
  12.         System.out.println("Interrupted");   
  13.       }   
  14.     }   
  15.   }   
  16. }   
  17. publicclass MyTest {   
  18. publicstaticvoid main(String[] args) {   
  19.     TestThreadMethod t1 = new TestThreadMethod("t1");   
  20.     TestThreadMethod t2 = new TestThreadMethod("t2");   
  21.     t1.start();   
  22. try {   
  23.       t1.join();   
  24.     } catch (InterruptedException e) {}   
  25.     t2.start();   
  26.   }   
  27. }   
 

 class TestThreadMethod extends Thread {

  public static int shareVar = 0;

  public TestThreadMethod(String name) {

    super(name);

  }

  public void run() {

    for (int i = 0; i < 4; i++) {

      System.out.println(" " + i);

      try {

        Thread.sleep(300);

      } catch (InterruptedException e) {

        System.out.println("Interrupted");

      }

    }

  }

}

public class MyTest {

  public static void main(String[] args) {

    TestThreadMethod t1 = new TestThreadMethod("t1");

    TestThreadMethod t2 = new TestThreadMethod("t2");

    t1.start();

    try {

      t1.join();

    } catch (InterruptedException e) {}

    t2.start();

  }

}

執行結果為：

引用: 0 1 2 3 0 1 2 3

3. class　Object下常用的執行緒函式 wait()、notify()和notifyAll()這三個函式由java.lang.Object類提供，用於協調多個執行緒對共享資料的存取。

3.1 wait()、notify()和notifyAll()

1) wait()函式有兩種形式：第一種形式接受一個毫秒值，用於在指定時間長度內暫停執行緒，使執行緒進入停滯狀態。第二種形式為不帶引數，代表waite()在notify()或notifyAll()之前會持續停滯。

2) 當對一個物件執行notify()時，會從執行緒等待池中移走該任意一個執行緒，並把它放到鎖標誌等待池中；當對一個物件執行notifyAll()時，會從執行緒等待池中移走所有該物件的所有執行緒，並把它們放到鎖標誌等待池中。

3) 當呼叫wait()後，執行緒會釋放掉它所佔有的“鎖標誌”，從而使執行緒所在物件中的其它synchronized資料可被別的執行緒使用。

例17： 下面，我們將對例11中的例子進行修改

  1. class TestThreadMethod extends Thread {   
  2. publicstaticint shareVar = 0;   
  3. public TestThreadMethod(String name) {   
  4. super(name);   
  5.   }   
  6. publicsynchronizedvoid run() {   
  7. if (shareVar == 0) {   
  8. for (int i = 0; i < 10; i++) {   
  9.         shareVar++;   
  10. if (shareVar == 5) {   
  11. try {   
  12. this.wait();// （4）
  13.           } catch (InterruptedException e) {}   
  14.         }   
  15.       }   
  16.     }   
  17. if (shareVar != 0) {   
  18.       System.out.print(Thread.currentThread().getName());   
  19.       System.out.println(" shareVar = " + shareVar);   
  20. this.notify();// （5）
  21.     }   
  22.   }   
  23. }   
  24. publicclass MyTest {   
  25. publicstaticvoid main(String[] args) {   
  26.     TestThreadMethod t1 = new TestThreadMethod("t1");   
  27.     TestThreadMethod t2 = new TestThreadMethod("t2");   
  28. new Thread(t1).start();// （1）
  29. // new Thread(t1).start(); // （2）
  30. new Thread(t2).start();// （3）
  31.   }   
  32. }   
 

class TestThreadMethod extends Thread {

  public static int shareVar = 0;

  public TestThreadMethod(String name) {

    super(name);

  }

  public synchronized void run() {

    if (shareVar == 0) {

      for (int i = 0; i < 10; i++) {

        shareVar++;

        if (shareVar == 5) {

          try {

            this.wait();// （4）

          } catch (InterruptedException e) {}

        }

      }

    }

    if (shareVar != 0) {

      System.out.print(Thread.currentThread().getName());

      System.out.println(" shareVar = " + shareVar);

      this.notify();// （5）

    }

  }

}

public class MyTest {

  public static void main(String[] args) {

    TestThreadMethod t1 = new TestThreadMethod("t1");

    TestThreadMethod t2 = new TestThreadMethod("t2");

    new Thread(t1).start();// （1）

    // new Thread(t1).start(); // （2）

    new Thread(t2).start();// （3）

  }

}

執行結果為：

引用: Thread-1 shareVar = 5

因為t1和t2是兩個不同物件，所以執行緒t2呼叫程式碼（5）不能喚起執行緒t1。如果去掉程式碼（2）的註釋，並註釋掉程式碼（3），結果為：

引用: Thread-1 shareVar = 5 Thread-0 shareVar = 10

這是因為，當代碼（1）的執行緒執行到程式碼（4）時，它進入停滯狀態，並釋放物件的鎖狀態。接著，程式碼（2）的執行緒執行run()，由於此時shareVar值為5，所以執行列印語句並呼叫程式碼（5）使程式碼（1）的執行緒進入可執行狀態，然後程式碼（2）的執行緒結束。當代碼（1）的執行緒重新執行後，它接著執行for()迴圈一直到shareVar=10，然後列印shareVar。

3.2 wait()、notify()和synchronized

waite()和notify()因為會對物件的“鎖標誌”進行操作，所以它們必須在synchronized函式或synchronized　block中進行呼叫。如果在non-synchronized函式或non-synchronized　block中進行呼叫，雖然能編譯通過，但在執行時會發生IllegalMonitorStateException的異常。

例18：

  1. class TestThreadMethod extends Thread {   
  2. publicint shareVar = 0;   
  3. public TestThreadMethod(String name) {   
  4. super(name);   
  5. new Notifier(this);   
  6.   }   
  7. publicsynchronizedvoid run() {   
  8. if (shareVar == 0) {   
  9. for (int i = 0; i < 5; i++) {   
  10.         shareVar++;   
  11.         System.out.println("i = " + shareVar);   
  12. try {   
  13.           System.out.println("wait......");   
  14. this.wait();   
  15.         } catch (InterruptedException e) {}   
  16.       }   
  17.     }   
  18.   }   
  19. }   
  20. class Notifier extends Thread {   
  21. private TestThreadMethod ttm;   
  22.   Notifier(TestThreadMethod t) {   
  23.     ttm = t;   
  24.     start();   
  25.   }   
  26. publicvoid run() {   
  27. while (true) {   
  28. try {   
  29.         sleep(2000);   
  30.       } catch (InterruptedException e) {}   
  31. /* 1 要同步的不是當前物件的做法 */
  32. synchronized (ttm) {   
  33.         System.out.println("notify......");   
  34.         ttm.notify();   
  35.       }   
  36.     }   
  37.   }   
  38. }   
  39. publicclass MyTest {   
  40. publicstaticvoid main(String[] args) {   
  41.     TestThreadMethod t1 = new TestThreadMethod("t1");   
  42.     t1.start();   
  43.   }   
  44. }   
 

class TestThreadMethod extends Thread {

  public int shareVar = 0;

  public TestThreadMethod(String name) {

    super(name);

    new Notifier(this);

  }

  public synchronized void run() {

    if (shareVar == 0) {

      for (int i = 0; i < 5; i++) {

        shareVar++;

        System.out.println("i = " + shareVar);

        try {

          System.out.println("wait......");

          this.wait();

        } catch (InterruptedException e) {}

      }

    }

  }

}

class Notifier extends Thread {

  private TestThreadMethod ttm;

  Notifier(TestThreadMethod t) {

    ttm = t;

    start();

  }

  public void run() {

    while (true) {

      try {

        sleep(2000);

      } catch (InterruptedException e) {}

      /* 1 要同步的不是當前物件的做法 */

      synchronized (ttm) {

        System.out.println("notify......");

        ttm.notify();

      }

    }

  }

}

public class MyTest {

  public static void main(String[] args) {

    TestThreadMethod t1 = new TestThreadMethod("t1");

    t1.start();

  }

}

執行結果為：

引用: i = 1 wait...... notify...... i = 2 wait...... notify...... i = 3 wait...... notify...... i = 4 wait...... notify...... i = 5 wait...... notify...... notify...... notify......

4. wait()、notify()、notifyAll()和suspend()、resume()、sleep()的討論

4.1 這兩組函式的區別

1) wait()使當前執行緒進入停滯狀態時，還會釋放當前執行緒所佔有的“鎖標誌”，從而使執行緒物件中的synchronized資源可被物件中別的執行緒使用；而suspend()和sleep()使當前執行緒進入停滯狀態時不會釋放當前執行緒所佔有的“鎖標誌”。

2) 前一組函式必須在synchronized函式或synchronized　block中呼叫，否則在執行時會產生錯誤；而後一組函式可以non-synchronized函式和synchronized　block中呼叫。

4.2 這兩組函式的取捨 Java2已不建議使用後一組函式。因為在呼叫wait()時不會釋放當前執行緒所取得的“鎖標誌”，這樣很容易造成“死鎖”。

相關推薦

java中yield(),sleep()以及wait()的區別(修正版)(轉帖)

往往混淆了這三個函式的使用。 從作業系統的角度講，os會維護一個ready queue（就緒的執行緒佇列）。並且在某一時刻cpu只為ready queue中位於佇列頭部的執行緒服務。 但是當前正在被服務的執行緒可能覺得cpu的服務質量不夠好，於是提前退出，這就是yield。

java中的sleep()和wait()的區別

except 的區別 獲取對象 waiting 區別 ace enter thread .html 引自：https://www.cnblogs.com/hongten/p/hongten_java_sleep_wait.html 對於sleep()方法，我們首先要知道該方

java 中的sleep()和wait() 等的區別和詳解

1、sleep() 　　使當前執行緒（即呼叫該方法的執行緒）暫停執行一段時間，讓其他執行緒有機會繼續執行，但它並不釋放物件鎖。也就是說如果有synchronized同步快，其他執行緒仍然不能訪問共享資料。注意該方法要捕捉異常。 例如有兩個執行緒同時執行(沒有

java 中的sleep()和wait() 的區別

1、sleep()　　使當前執行緒（即呼叫該方法的執行緒）暫停執行一段時間，讓其他執行緒有機會繼續執行，但它並不釋放物件鎖。也就是說如果有synchronized同步快，其他執行緒仍然不能訪問共享資料。注意該方法要捕捉異常。 例如有兩個執行緒同時執行(沒有synchronized)一個執行緒優先順序為MAX_

黑馬程式設計師：yield(),sleep()以及wait()的區別

---------------------- android培訓、java培訓、期待與您交流！ -------------------- 作為一個學java的人，我覺得yield(),sleep()以及wait()是一道難以越過的坎兒，看到論壇上有很多人討論這個問題

java中的 sleep() 和 wait() 有什麽區別？

導致 java bsp ble exc star pri static 同步塊 1、每個對象都有一個鎖來控制同步訪問，Synchronized關鍵字可以和對象的鎖交互，來實現同步方法或同步塊。sleep()方法正在執行的線程主動讓出CPU（然後CPU就可以去執行其他任務），

java執行緒中yield(),sleep(),wait()區別詳解

1、sleep() 使當前執行緒（即呼叫該方法的執行緒）暫停執行一段時間，讓其他執行緒有機會繼續執行，但它並不釋放物件鎖。也就是說如果有synchronized同步快，其他執行緒仍然不能訪問共享資料。

java之yield(),sleep(),wait()區別詳解

yield 其他 哪些 AD 不能訪問 機制 內存 strong 一段 1、sleep() 使當前線程（即調用該方法的線程）暫停執行一段時間，讓其他線程有機會繼續執行，但它並不釋放對象鎖。也就是說如果有synchronized同步快，其他線程仍然不能訪問共享數據。註意該方

Java中sleep()與wait()區別

學習時正好碰到這兩個方法，就查閱相關資料，並通過程式實現，進行區別一下：1、每個物件都有一個鎖來控制同步訪問，Synchronized關鍵字可以和物件的鎖互動，來實現同步方法或同步塊。sleep()方法正在執行的執行緒主動讓出CPU（然後CPU就可以去執行其他任務），在slee

java之yield(),sleep(),wait()區別詳解-備忘筆記

source: http://dylanxu.iteye.com/blog/1322066 1、sleep() 使當前執行緒（即呼叫該方法的執行緒）暫停執行一段時間，讓其他執行緒有機會繼續執行，但它並不釋放物件鎖。也就是說如果有synchronized同步快，其他執行

Java中sleep()與wait()區別標記一下

學習時正好碰到這兩個方法，就查閱相關資料，並通過程式實現，進行區別一下： 1、每個物件都有一個鎖來控制同步訪問，Synchronized關鍵字可以和物件的鎖互動，來實現同步方法或同步塊。sleep()方法正在執行的執行緒主動讓出CPU（然後CPU就可以去執行其他任務），

Java中this與super的區別以及用法

輸出結果 類構造 pan tex 成員變量 靜態 public 裏的 一個 super（）用法 super()函數在子類構造函數中調用父類的構造函數時使用，必須要在構造函數的第一行。 1 class Animal { 2 public Anima

JAVA中String,StringBuilder以及StringBuffer三個類之間的區別

不斷地學習，不斷地填充自己的技術庫，學習Java已經有一段時間了，由一開始的不適應到後來的足以靈活應對，不僅僅取決於老師的精緻講課，還有就是依靠我的學習祕籍：記錄自己的學習筆記。今天給大家分享的技術學習筆記是JAVAString,StringBuilder以及StringBuffer這三個類之間的區別。 &

Java 執行緒sleep() 和 wait()的區別

sleep(休眠) 和 wait(等待) 方法是 Java 多執行緒中常用的兩個方法 區別1：使用限制 使用 sleep 方法可以讓當前執行緒休眠，時間一到當前執行緒繼續往下執行，在任何地方都能使用

Java併發之sleep() 和 wait(n) 、 wait() 的區別

sleep() 和 wait(n) 、 wait() 的區別 答： sleep 方法：是 Thread 類的靜態方法，當前執行緒將睡眠 n 毫秒，執行緒進入阻塞狀態。當睡眠時間到了，會接觸阻塞，進入可

【詳】JAVA中異常分類以及異常處理方法之間的區別以及聯絡

異常在日長開發中就像看見地鐵裡邊的人頭一樣的，放眼望去，齊刷刷的一片，各種異常。分佈範圍比較廣泛，很多人看到異常，就這表情 JAVA中異常： NullPointerException 空指標異常

多執行緒同步中sleep與wait區別

1、函式 wait是Object的一個函式，指執行緒處於進入等待狀態，此時執行緒不佔用任何資源，不增加時間限制。wait可以被notify和notifyAll函式喚醒（這兩個也是Object的函

java執行緒中yield()和join()的區別

package test.core.threads; public class JoinExample { public static void main(String[] args) throws InterruptedException { Thread t = new Thr

java中過載與重寫的區別以及與多型的關係

　　首先我們來講講：過載(Overloading)     （1） 方法過載是讓類以統一的方式處理不同型別資料的一種手段。多個同名函式同時存在，具有不同的引數個數/型別。 過載Overloading是一個類中多型性的一種表現。     （2） Java的方法過載，就是在類中可以建立多

java中的Iterator和Iterable 區別 ，以及為麼要有iterable介面

java.lang.Iterable java.util.Iterator 來自百度知道： Iterator是迭代器類（其實在javaAPI中其也是一個介面），而Iterable是介面。 好多類都實現了Iterable介面，這樣物件就可以呼叫iterator()方法