Java多線程系列--「基礎篇」07之線程休眠

時間 2019-11-22

標籤 java 多線程系列基礎線程休眠欄目 Java 简体版

原文原文鏈接

概要

本章，會對Thread中sleep()方法進行介紹。涉及到的內容包括：
1. sleep()介紹
 2. sleep()示例
 3. sleep() 與 wait()的比較html

轉載請註明出處：http://www.cnblogs.com/skywang12345/p/3479256.htmljava

1. sleep()介紹

sleep() 定義在Thread.java中。
sleep() 的做用是讓當前線程休眠，即當前線程會從「運行狀態」進入到「休眠(阻塞)狀態」。sleep()會指定休眠時間，線程休眠的時間會大於/等於該休眠時間；在線程從新被喚醒時，它會由「阻塞狀態」變成「就緒狀態」，從而等待cpu的調度執行。多線程

2. sleep()示例

下面經過一個簡單示例演示sleep()的用法。this

 1 // SleepTest.java的源碼
 2 class ThreadA extends Thread{
 3     public ThreadA(String name){ 
 4         super(name); 
 5     } 
 6     public synchronized void run() { 
 7         try {
 8             for(int i=0; i <10; i++){ 
 9                 System.out.printf("%s: %d\n", this.getName(), i); 
10                 // i能被4整除時，休眠100毫秒
11                 if (i%4 == 0)
12                     Thread.sleep(100);
13             } 
14         } catch (InterruptedException e) {
15             e.printStackTrace();
16         }
17     } 
18 } 
19 
20 public class SleepTest{ 
21     public static void main(String[] args){ 
22         ThreadA t1 = new ThreadA("t1"); 
23         t1.start(); 
24     } 
25 }

運行結果：spa

t1: 0
t1: 1
t1: 2
t1: 3
t1: 4
t1: 5
t1: 6
t1: 7
t1: 8
t1: 9

結果說明：
程序比較簡單，在主線程main中啓動線程t1。t1啓動以後，當t1中的計算i能被4整除時，t1會經過Thread.sleep(100)休眠100毫秒。線程

3. sleep() 與 wait()的比較

咱們知道，wait()的做用是讓當前線程由「運行狀態」進入「等待(阻塞)狀態」的同時，也會釋放同步鎖。而sleep()的做用是也是讓當前線程由「運行狀態」進入到「休眠(阻塞)狀態」。
可是，wait()會釋放對象的同步鎖，而sleep()則不會釋放鎖。
下面經過示例演示sleep()是不會釋放鎖的。code

 1 // SleepLockTest.java的源碼
 2 public class SleepLockTest{ 
 3 
 4     private static Object obj = new Object();
 5 
 6     public static void main(String[] args){ 
 7         ThreadA t1 = new ThreadA("t1"); 
 8         ThreadA t2 = new ThreadA("t2"); 
 9         t1.start(); 
10         t2.start();
11     } 
12 
13     static class ThreadA extends Thread{
14         public ThreadA(String name){ 
15             super(name); 
16         } 
17         public void run(){ 
18             // 獲取obj對象的同步鎖
19             synchronized (obj) {
20                 try {
21                     for(int i=0; i <10; i++){ 
22                         System.out.printf("%s: %d\n", this.getName(), i); 
23                         // i能被4整除時，休眠100毫秒
24                         if (i%4 == 0)
25                             Thread.sleep(100);
26                     }
27                 } catch (InterruptedException e) {
28                     e.printStackTrace();
29                 }
30             }
31         } 
32     } 
33 }

運行結果：htm

t1: 0
t1: 1
t1: 2
t1: 3
t1: 4
t1: 5
t1: 6
t1: 7
t1: 8
t1: 9
t2: 0
t2: 1
t2: 2
t2: 3
t2: 4
t2: 5
t2: 6
t2: 7
t2: 8
t2: 9

結果說明：
主線程main中啓動了兩個線程t1和t2。t1和t2在run()會引用同一個對象的同步鎖，即synchronized(obj)。在t1運行過程當中，雖然它會調用Thread.sleep(100)；可是，t2是不會獲取cpu執行權的。由於，t1並無釋放「obj所持有的同步鎖」！
注意，若咱們註釋掉synchronized (obj)後再次執行該程序，t1和t2是能夠相互切換的。下面是註釋調synchronized(obj) 以後的源碼：對象

 1 // SleepLockTest.java的源碼(註釋掉synchronized(obj))
 2 public class SleepLockTest{ 
 3 
 4     private static Object obj = new Object();
 5 
 6     public static void main(String[] args){ 
 7         ThreadA t1 = new ThreadA("t1"); 
 8         ThreadA t2 = new ThreadA("t2"); 
 9         t1.start(); 
10         t2.start();
11     } 
12 
13     static class ThreadA extends Thread{
14         public ThreadA(String name){ 
15             super(name); 
16         } 
17         public void run(){ 
18             // 獲取obj對象的同步鎖
19 //            synchronized (obj) {
20                 try {
21                     for(int i=0; i <10; i++){ 
22                         System.out.printf("%s: %d\n", this.getName(), i); 
23                         // i能被4整除時，休眠100毫秒
24                         if (i%4 == 0)
25                             Thread.sleep(100);
26                     }
27                 } catch (InterruptedException e) {
28                     e.printStackTrace();
29                 }
30 //            }
31         } 
32     } 
33 }