Java多線程案例

1. 多線程的創建方式

（1）、繼承 Thread類：但Thread本質上也是實現了Runnable 接口的一個實例，它代表一個線程的實例，並且，啟動線程的唯一方法就是通過 Thread 類的 start()實例方法。start()方法是一個 native 方法，它將啟動一個新線程，並執行run()方法。這種方式實現多線程很簡單，通過自己的類直接extend Thread，並復寫run()方法，就可以啟動新線程並執行自己定義的run()方法。例如：繼承Thread類實現多線程，並在合適的地方啟動線程

 

1．public class MyThread extends Thread {   
2．  public void run() {   
3．   System.out.println("MyThread.run()");   
4．  }   
5．}  
 
6．MyThread myThread1 = new MyThread();   
7．MyThread myThread2 = new MyThread();   
8．myThread1.start();   
9．myThread2.start();

（2）、實現Runnable接口的方式實現多線程，並且實例化Thread，傳入自己的Thread實例，調用run( )方法 

1．public class MyThread implements Runnable {   
2．  public void run() {   
3．   System.out.println("MyThread.run()");   
4．  }   
5．} 
6．MyThread myThread = new MyThread();   
7．Thread thread = new Thread(myThread);   
8．thread.start(); 

（3）、使用ExecutorService、Callable、Future實現有返回結果的多線程：ExecutorService、Callable、Future這 個 對 象 實際 上 都是屬 於 Executor 框 架中 的 功 能 類。 想 要詳細 了 解 Executor 框架 的 可 以 訪問http://www.javaeye.com/topic/366591 ，這里面對該框架做了很詳細的解釋。返回結果的線程是在JDK1.5中引入的新特征，確實很實用，有了這種特征我就不需要再為了得到返回值而大費周折了，而且即便實現了也可能漏洞百出。可返回值的任務必須實現Callable接口，類似的，無返回值的任務必須Runnable接口。執行Callable任務后，可以獲取一個 Future 的對象，在該對象上調用 get 就可以獲取到 Callable 任務返回的 Object 了，再結合線程池接口ExecutorService就可以實現傳說中有返回結果的多線程了。下面提供了一個完整的有返回結果的多線程測試例子，在JDK1.5下驗證過沒問題可以直接使用。代碼如下：

1．import java.util.concurrent.*;   
2．import java.util.Date;   
3．import java.util.List;   
4．import java.util.ArrayList;   
5．   
6．/**  
7．* 有返回值的線程  
8．*/   
9．@SuppressWarnings("unchecked")   
10．public class Test {   
11．public static void main(String[] args) throws ExecutionException,   
12．    InterruptedException {   
13．   System.out.println("----程序開始運行----");   
14．   Date date1 = new Date();   
15．   
16．   int taskSize = 5;   
17．   // 創建一個線程池   
18．   ExecutorService pool = Executors.newFixedThreadPool(taskSize);   
19．   // 創建多個有返回值的任務   
20．   List<Future> list = new ArrayList<Future>();   
21．   for (int i = 0; i < taskSize; i++) {   
22．    Callable c = new MyCallable(i + " ");   
23．    // 執行任務並獲取 Future 對象   
24．    Future f = pool.submit(c);   
25．    // System.out.println(">>>" + f.get().toString());   
26．    list.add(f);   
27．   }   
28．   // 關閉線程池   
29．   pool.shutdown();   
30．   
31．   // 獲取所有並發任務的運行結果   
32．   for (Future f : list) {   
33．    // 從 Future 對象上獲取任務的返回值，並輸出到控制台   
34．    System.out.println(">>>" + f.get().toString());   
35．   }   
36．   
37．   Date date2 = new Date();   
38．   System.out.println("----程序結束運行----，程序運行時間【"   
39．     + (date2.getTime() - date1.getTime()) + "毫秒】");   
40．}   
41．}   
42．   
43．class MyCallable implements Callable<Object> {   
44．private String taskNum;   
45．   
46．MyCallable(String taskNum) {   
47．   this.taskNum = taskNum;   
48．}   
49．   
50．public Object call() throws Exception {   
51．   System.out.println(">>>" + taskNum + "任務啟動");   
52．   Date dateTmp1 = new Date();   
53．   Thread.sleep(1000);   
54．   Date dateTmp2 = new Date();   
55．   long time = dateTmp2.getTime() - dateTmp1.getTime();   
56．   System.out.println(">>>" + taskNum + "任務終止");   
57．   return taskNum + "任務返回運行結果,當前任務時間【" + time + "毫秒】";   58．}   
59．} 

2. 在 java 中 wait 和 sleep 方法的不同？ 

最大的不同是在等待時wait會釋放鎖，而sleep一直持有鎖。wait通常被用於線程間交互，sleep通常被用於暫停執行。

3. synchronized 和 volatile 關鍵字的作用
一旦一個共享變量（類的成員變量、類的靜態成員變量）被volatile修飾之后，那么就具備了兩層語義：
1）保證了不同線程對這個變量進行操作時的可見性，即一個線程修改了某個變量的值，這新值對其他線程來說是
立即可見的。
2）禁止進行指令重排序。
volatile本質是在告訴jvm當前變量在寄存器（工作內存）中的值是不確定的，需要從主存中讀取；
synchronized則是鎖定當前變量，只有當前線程可以訪問該變量，其他線程被阻塞住。
1.volatile僅能使用在變量級別；
synchronized則可以使用在變量、方法、和類級別的
2.volatile僅能實現變量的修改可見性，並不能保證原子性；
synchronized則可以保證變量的修改可見性和原子性
3.volatile不會造成線程的阻塞；
synchronized可能會造成線程的阻塞。
4.volatile標記的變量不會被編譯器優化；
synchronized標記的變量可以被編譯器優化

4. 分析線程並發訪問代碼解釋原因 

1. public class Counter { 
2.  private volatile int count = 0; 
3.  public void inc(){ 
4.   try { 
5.    Thread.sleep(3); 
6.   } catch (InterruptedException e) { 
7.    e.printStackTrace(); 
8.   } 
9.   count++; 
10.  } 
11.  @Override 
12.  public String toString() { 
13.   return "[count=" + count + "]"; 
14.  } 
15. }  
16. //---------------------------------華麗的分割線----------------------------- 
17. public class VolatileTest { 
18.  public static void main(String[] args) { 
19.   final Counter counter = new Counter(); 
20.   for(int i=0;i<1000;i++){ 
21.    new Thread(new Runnable() { 
22.     @Override 
23.     public void run() { 
24.      counter.inc(); 
25.     } 
26.    }).start(); 
27.   } 
28.   System.out.println(counter); 
29.  } 
30. } 

上面的代碼執行完后輸出的結果確定為1000嗎？
答案是不一定，或者不等於1000。這是為什么嗎？
在 java 的內存模型中每一個線程運行時都有一個線程棧，線程棧保存了線程運行時候變量值信息。當線程訪問某一個對象時候值的時候，首先通過對象的引用找到對應在堆內存的變量的值，然后把堆內存變量的具體值load到線程本地內存中，建立一個變量副本，之后線程就不再和對象在堆內存變量值有任何關系，而是直接修改副本變量的值，在修改完之后的某一個時刻（線程退出之前），自動把線程變量副本的值回寫到對象在堆中變量。這樣在堆中的對象的值就產生變化了。
也就是說上面主函數中開啟了 1000 個子線程，每個線程都有一個變量副本，每個線程修改變量只是臨時修改了自己的副本，當線程結束時再將修改的值寫入在主內存中，這樣就出現了線程安全問題。因此結果就不可能等於1000了，一般都會小於1000。

 

5. 什么是線程池，如何使用？

 

線程池就是事先將多個線程對象放到一個容器中，當使用的時候就不用new線程而是直接去池中拿線程即可，節省了開辟子線程的時間，提高的代碼執行效率。
在JDK的java.util.concurrent.Executors中提供了生成多種線程池的靜態方法。

 

1. ExecutorService newCachedThreadPool = Executors.newCachedThreadPool(); 
2. ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(4); 
3. ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(4); 
4. ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor(); 

然后調用他們的 execute 方法即可。 

6. 常用的線程池有哪些？

newSingleThreadExecutor：創建一個單線程的線程池，此線程池保證所有任務的執行順序按照任務的提交順序執行。
newFixedThreadPool：創建固定大小的線程池，每次提交一個任務就創建一個線程，直到線程達到線程池的最大大小。
newCachedThreadPool：創建一個可緩存的線程池，此線程池不會對線程池大小做限制，線程池大小完全依賴於操作系統（或者說JVM）能夠創建的最大線程大小。
newScheduledThreadPool：創建一個大小無限的線程池，此線程池支持定時以及周期性執行任務的需求。
newSingleThreadExecutor：創建一個單線程的線程池。此線程池支持定時以及周期性執行任務的需求。

7. 請敘述一下您對線程池的理解？

第一：降低資源消耗。通過重復利用已創建的線程降低線程創建和銷毀造成的消耗。
第二：提高響應速度。當任務到達時，任務可以不需要等到線程創建就能立即執行。
第三：提高線程的可管理性。線程是稀缺資源，如果無限制的創建，不僅會消耗系統資源，還會降低系統的穩定性，使用線程池可以進行統一的分配，調優和監控。

 

8. 線程池的啟動策略？

官方對線程池的執行過程描述如下： 

26.  /* 
27.          * Proceed in 3 steps: 
28.          * 
29.          * 1. If fewer than corePoolSize threads are running, try to 
30.          * start a new thread with the given command as its first 
31.          * task.  The call to addWorker atomically checks runState and 
32.          * workerCount, and so prevents false alarms that would add 
33.          * threads when it shouldn't, by returning false. 
34.          * 
35.          * 2. If a task can be successfully queued, then we still need 
36.          * to double-check whether we should have added a thread 
37.          * (because existing ones died since last checking) or that 
38.          * the pool shut down since entry into this method. So we 
39.          * recheck state and if necessary roll back the enqueuing if 
40.          * stopped, or start a new thread if there are none. 
41.          * 
42.          * 3. If we cannot queue task, then we try to add a new 
43.          * thread.  If it fails, we know we are shut down or saturated 
44.          * and so reject the task. 
45.          */ 

1、線程池剛創建時，里面沒有一個線程。任務隊列是作為參數傳進來的。不過，就算隊列里面有任務，線程池也不會馬上執行它們。
2、當調用execute() 方法添加一個任務時，線程池會做如下判斷：
a. 如果正在運行的線程數量小於 corePoolSize，那么馬上創建線程運行這個任務；
b. 如果正在運行的線程數量大於或等於 corePoolSize，那么將這個任務放入隊列。
c. 如果這時候隊列滿了，而且正在運行的線程數量小於 maximumPoolSize，那么還是要創建線程運行這個任務；
d. 如果隊列滿了，而且正在運行的線程數量大於或等於 maximumPoolSize，那么線程池會拋出異常，告訴調用者“我不能再接受任務了”。
3、當一個線程完成任務時，它會從隊列中取下一個任務來執行。
4、當一個線程無事可做，超過一定的時間（keepAliveTime）時，線程池會判斷，如果當前運行的線程數大於corePoolSize，那么這個線程就被停掉。所以線程池的所有任務完成后，它最終會收縮到 corePoolSize 的大小。

9. 如何控制某個方法允許並發訪問線程的個數？

可以使用Semaphore控制，第16行的構造函數創建了一個Semaphore對象，並且初始化了5個信號。這樣的效果是控件 test 方法最多只能有 5 個線程並發訪問，對於 5 個線程時就排隊等待，走一個來一下。第 33行，請求一個信號（消費一個信號），如果信號被用完了則等待，第45行釋放一個信號，釋放的信號新的線程就可以使用了。

10. 三個線程 a、b、c 並發運行，b,c 需要 a 線程的數據怎么實現

根據問題的描述，我將問題用以下代碼演示，ThreadA、ThreadB、ThreadC，ThreadA 用於初始化數據 num，只有當num初始化完成之后再讓ThreadB和ThreadC獲取到初始化后的變量num。
分析過程如下：
考慮到多線程的不確定性，因此我們不能確保ThreadA就一定先於ThreadB和ThreadC前執行，就算ThreadA先執行了，我們也無法保證ThreadA什么時候才能將變量num給初始化完成。因此我們必須讓ThreadB和ThreadC去等待ThreadA完成任何后發出的消息。
現在需要解決兩個難題，一是讓 ThreadB 和 ThreadC 等待 ThreadA 先執行完，二是 ThreadA 執行完之后給ThreadB和ThreadC發送消息。
解決上面的難題我能想到的兩種方案，一是使用純Java API的Semaphore類來控制線程的等待和釋放，二是使用Android提供的Handler消息機制。

1. package com.example; 
2. /** 
3.  * 三個線程 a、b、c 並發運行，b,c 需要 a 線程的數據怎么實現（上海 3 期學員提供） 4.  * 
5.  */ 
6. public class ThreadCommunication { 
7.  private static int num;//定義一個變量作為數據 
8.   
9.  public static void main(String[] args) { 
10.    
11.   Thread threadA = new Thread(new Runnable() { 
12.     
13.    @Override 
14.    public void run() { 
15.     try { 
16.      //模擬耗時操作之后初始化變量 num 
17.      Thread.sleep(1000); 
18.      num = 1; 
19.       
20.     } catch (InterruptedException e) { 
21.      e.printStackTrace(); 
22.     } 
23.    } 
24.   }); 
25.   Thread threadB = new Thread(new Runnable() { 
26.     
27.    @Override 
28.    public void run() { 
29.     System.out.println(Thread.currentThread().getName()+"獲取到 num 的值為："+num); 
30.    } 
31.   }); 
32.   Thread threadC = new Thread(new Runnable() { 
33.     
34.    @Override 
35.    public void run() { 
36.     System.out.println(Thread.currentThread().getName()+"獲取到 num 的值為："+num); 
37.    } 
38.   }); 
39.   //同時開啟 3 個線程 
40.   threadA.start(); 
41.   threadB.start(); 
42.   threadC.start(); 
43.    
44.  } 
45. } 
46.

解決方案:

1. public class ThreadCommunication { 
2.  private static int num; 
3.  /** 
4.   * 定義一個信號量，該類內部維持了多個線程鎖，可以阻塞多個線程，釋放多個線程， 
5. 線程的阻塞和釋放是通過 permit 概念來實現的 
6.   * 線程通過 semaphore.acquire()方法獲取 permit，如果當前 semaphore 有 permit 則分配給該線程， 
7. 如果沒有則阻塞該線程直到 semaphore 
8.   * 調用 release（）方法釋放 permit。 
9.   * 構造函數中參數：permit（允許） 個數， 
10.   */ 
11.  private static Semaphore semaphore = new Semaphore(0); 
12.  public static void main(String[] args) { 
13.    
14.   Thread threadA = new Thread(new Runnable() { 
15.     
16.    @Override 
17.    public void run() { 
18.     try { 
19.      //模擬耗時操作之后初始化變量 num 
20.      Thread.sleep(1000); 
21.      num = 1; 
22.      //初始化完參數后釋放兩個 permit 
23.      semaphore.release(2); 
24.       
25.     } catch (InterruptedException e) { 
26.      e.printStackTrace(); 
27.     } 
28.    } 
29.   }); 
30.   Thread threadB = new Thread(new Runnable() { 
31.     
32.    @Override 
33.    public void run() { 
34.     try { 
35.      //獲取 permit，如果 semaphore 沒有可用的 permit 則等待，如果有則消耗一個 
36.      semaphore.acquire(); 
37.     } catch (InterruptedException e) { 
38.      e.printStackTrace(); 
39.     } 
40.     System.out.println(Thread.currentThread().getName()+"獲取到 num 的值為："+num); 
41.    } 
42.   }); 
43.   Thread threadC = new Thread(new Runnable() { 
44.     
45.    @Override 
46.    public void run() { 
47.     try { 
48.      //獲取 permit，如果 semaphore 沒有可用的 permit 則等待，如果有則消耗一個 
49.      semaphore.acquire(); 
50.     } catch (InterruptedException e) { 
51.      e.printStackTrace(); 
52.     } 
53.     System.out.println(Thread.currentThread().getName()+"獲取到 num 的值為："+num); 
54.    } 
55.   }); 
56.   //同時開啟 3 個線程 
57.   threadA.start(); 
58.   threadB.start(); 
59.   threadC.start(); 
60.    
61.  } 
62. }

11. 同一個類中的 2 個方法都加了同步鎖，多個線程能同時訪問同一個類中的這兩個方法嗎？

這個問題需要考慮到Lock與synchronized 兩種實現鎖的不同情形。因為這種情況下使用Lock 和synchronized 會有截然不同的結果。Lock可以讓等待鎖的線程響應中斷，Lock獲取鎖，之后需要釋放鎖。如下代碼，多個線程不可訪問同一個類中的2個加了Lock鎖的方法。

而synchronized卻不行，使用synchronized時，當我們訪問同一個類對象的時候，是同一把鎖，所以可以訪問該對象的其他synchronized方法。

12. 什么情況下導致線程死鎖，遇到線程死鎖該怎么解決?

11.1 死鎖的定義：所謂死鎖是指多個線程因競爭資源而造成的一種僵局（互相等待），若無外力作用，這些進程都將無法向前推進。
11.2 死鎖產生的必要條件：
互斥條件：線程要求對所分配的資源（如打印機）進行排他性控制，即在一段時間內某 資源僅為一個線程所占有。此時若有其他線程請求該資源，則請求線程只能等待。
不剝奪條件：線程所獲得的資源在未使用完畢之前，不能被其他線程強行奪走，即只能由獲得該資源的線程自己來釋放（只能是主動釋放)。
請求和保持條件：線程已經保持了至少一個資源，但又提出了新的資源請求，而該資源已被其他線程占有，此時請求進程被阻塞，但對自己已獲得的資源保持不放。
循環等待條件：存在一種線程資源的循環等待鏈，鏈中每一個線程已獲得的資源同時被鏈中下一個線程所請求。即存在一個處於等待狀態的線程集合{Pl, P2, ..., pn}，其中Pi等待的資源被P(i+1)占有（i=0, 1, ..., n-1)，Pn等待的資源被P0占有

產生死鎖的一個例子

1．package .com; 
2．/** 
3．* 一個簡單的死鎖類 
4．* 當 DeadLock 類的對象 flag==1 時（td1），先鎖定 o1,睡眠 500 毫秒 
5．* 而 td1 在睡眠的時候另一個 flag==0 的對象（td2）線程啟動，先鎖定 o2,睡眠 500 毫秒   
6．* td1 睡眠結束后需要鎖定 o2 才能繼續執行，而此時 o2 已被 td2 鎖定；   
7．* td2 睡眠結束后需要鎖定 o1 才能繼續執行，而此時 o1 已被 td1 鎖定；   
8．* td1、td2 相互等待，都需要得到對方鎖定的資源才能繼續執行，從而死鎖。   
9．*/     
10．public class DeadLock implements Runnable {     
11．    public int flag = 1;     
12．    //靜態對象是類的所有對象共享的     
13．    private static Object o1 = new Object(), o2 = new Object();     
14．    public void run() {     
15．        System.out.println("flag=" + flag);     
16．        if (flag == 1) {     
17．            synchronized (o1) {     
18．                try {     
19．                    Thread.sleep(500);     
20．                } catch (Exception e) {     
21．                    e.printStackTrace();     
22．                }     
23．                synchronized (o2) {     
24．                    System.out.println("1");     
25．                }     
26．            }     
27．        }     
28．        if (flag == 0) {     
29．            synchronized (o2) {     
30．                try {     
31．                    Thread.sleep(500);     
32．                } catch (Exception e) {     
33．                    e.printStackTrace();     
34．                }     
35．                synchronized (o1) {     
36．                    System.out.println("0");     
37．                }     
38．            }     
39．        }     
40．    }       
41．    public static void main(String[] args) {        
42．        DeadLock td1 = new DeadLock();     
43．        DeadLock td2 = new DeadLock();     
44．        td1.flag = 1;     
45．        td2.flag = 0;     
46．        //td1,td2 都處於可執行狀態，但 JVM 線程調度先執行哪個線程是不確定的。     47．        //td2 的 run()可能在 td1 的 run()之前運行     
48．        new Thread(td1).start();     
49．        new Thread(td2).start();     
50．    }     
51．} 

13. Java 中多線程間的通信怎么實現?

線程通信的方式：
1.共享變量
線程間通信可以通過發送信號，發送信號的一個簡單方式是在共享對象的變量里設置信號值。線程 A 在一個同步塊里設置 boolean 型成員變量 hasDataToProcess 為 true，線程 B 也在同步塊里讀取 hasDataToProcess這個成員變量。這個簡單的例子使用了一個持有信號的對象，並提供了 set 和 get 方法

1．package igeekhome.com; 
2．public class MySignal{ 
3． //共享的變量 
4． private boolean hasDataToProcess=false;  
5．  //取值 
6． public boolean getHasDataToProcess() { 
7．  return hasDataToProcess; 
8． } 
9．  //存值 
10． public void setHasDataToProcess(boolean hasDataToProcess) { 
11．  this.hasDataToProcess = hasDataToProcess; 
12． } 
13． public static void main(String[] args){ 
14．     //同一個對象 
15．  final MySignal my=new MySignal();  
16．     //線程 1 設置 hasDataToProcess 值為 true 
17．  final Thread t1=new Thread(new Runnable(){ 
18．   public void run() { 
19．    my.setHasDataToProcess(true); 
20．   }    
21．  });   
22．  t1.start();  
23．    //線程 2 取這個值 hasDataToProcess 
24．  Thread t2=new Thread(new Runnable(){ 
25．   public void run() { 
26．    try { 
27．                  //等待線程 1 完成然后取值 
28．     t1.join(); 
29．    } catch (InterruptedException e) { 
30．     e.printStackTrace(); 
31．    } 
32．    my.getHasDataToProcess(); 
33．    System.out.println("t1 改變以后的值：" + my.isHasDataToProcess()); 34．   }   
35．  });  
36．  t2.start(); 
37．} 
38．} 
結果： 
 
 t1 改變以后的值：true

2.wait/notify 機制
以資源為例，生產者生產一個資源，通知消費者就消費掉一個資源，生產者繼續生產資源，消費者消費資源，以此循環。代碼如下：

1．package igeekhome.com; 
2．//資源類 
3． class Resource{ 
4．    private String name;   
5．    private int count=1;   
6．    private boolean flag=false;   
7．    public synchronized void set(String name){   
8．     //生產資源 
9．        while(flag) { 
10．            try{ 
11．             //線程等待。消費者消費資源 
12．             wait(); 
13．             }catch(Exception e){}   
14．        } 
15．        this.name=name+"---"+count++;   
16．        System.out.println(Thread.currentThread().getName()+"...生產者..."+this.name);   
17．        flag=true;   
18．        //喚醒等待中的消費者 
19．        this.notifyAll(); 
20．        }   
21．    public synchronized void out(){  
22．     //消費資源 
23．        while(!flag) { 
24．         //線程等待，生產者生產資源 
25．            try{wait();}catch(Exception e){}   
26．        } 
27．        System.out.println(Thread.currentThread().getName()+"...消費者..."+this.name);   
28．        flag=false;   
29．        //喚醒生產者，生產資源 
30．        this.notifyAll();  
31．        }   
32．}   
33． //生產者 
34． class Producer implements Runnable{   
35．     private Resource res;   
36．     Producer(Resource res){   
37．         this.res=res;   
38．     }   
39．     //生產者生產資源 
40．     public void run(){   
41．         while(true){   
42．             res.set("商品");  
43．         }   
44．     }   
45． }   
46． //消費者消費資源 
47． class Consumer implements Runnable{   
48．     private Resource res;   
49．     Consumer(Resource res){   
50．         this.res=res;   
51．     }   
52．     public void run(){   
53．         while(true){   
54．             res.out();   
55．         }   
56．     }   
57． }   
58．public class ProducerConsumerDemo{   
59．    public static void main(String[] args){   
60．        Resource r=new Resource();   
61．        Producer pro=new Producer(r);   
62．        Consumer con=new Consumer(r);   
63．        Thread t1=new Thread(pro);   
64．        Thread t2=new Thread(con);   
65．        t1.start();   
66．        t2.start();   
67．    }   
68．} 

14. 線程和進程的區別

 

進程：具有一定獨立功能的程序關於某個數據集合上的一次運行活動，是操作系統進行資源分配和調度的一個獨立單位。
線程：是進程的一個實體，是cpu調度和分派的基本單位，是比進程更小的可以獨立運行的基本單位。
特點：線程的划分尺度小於進程，這使多線程程序擁有高並發性，進程在運行時各自內存單元相互獨立，線程之間內存共享，這使多線程編程可以擁有更好的性能和用戶體驗
注意：多線程編程對於其它程序是不友好的，占據大量cpu資源。

15. 請說出同步線程及線程調度相關的方法？

wait()：使一個線程處於等待（阻塞）狀態，並且釋放所持有的對象的鎖； 
sleep()：使一個正在運行的線程處於睡眠狀態，是一個靜態方法，調用此方法要處理InterruptedException異常； 
notify()：喚醒一個處於等待狀態的線程，當然在調用此方法的時候，並不能確切的喚醒某一個等待狀態的線程，
而是由JVM確定喚醒哪個線程，而且與優先級無關； 
notityAll()：喚醒所有處於等待狀態的線程，該方法並不是將對象的鎖給所有線程，而是讓它們競爭，只有獲得鎖
的線程才能進入就緒狀態； 
注意：java 5 通過Lock接口提供了顯示的鎖機制，Lock接口中定義了加鎖（lock（）方法）和解鎖（unLock（）
方法），增強了多線程編程的靈活性及對線程的協調 

16. 啟動一個線程是調用 run()方法還是 start()方法？

啟動一個線程是調用 start()方法，使線程所代表的虛擬處理機處於可運行狀態，這意味着它可以由 JVM 調度並執行，這並不意味着線程就會立即運行。
run()方法是線程啟動后要進行回調（callback）的方法。