![](http://img.blog.itpub.net/blog/2020/03/08/edde17d605fc2f24.png?x-oss-process=style/bb)

Java 給多執行緒程式設計提供了內建的支援。 一條執行緒指的是程式中一個單一順序的控制流，一個程式中可以併發多個執行緒，每條執行緒並行執行不同的任務。

多執行緒是多工的一種特別的形式，但多執行緒使用了更小的資源開銷。

這裡定義和執行緒相關的另一個術語 - 程式：一個程式包括由作業系統分配的記憶體空間，包含一個或多個執行緒。一個執行緒不能獨立的存在，它必須是程式的一部分。一個程式一直執行，直到所有的非守護執行緒都結束執行後才能結束。

多執行緒能滿足程式設計師編寫高效率的程式來達到充分利用 CPU 的目的。

# 一. 一個執行緒的生命週期

執行緒是一個動態執行的過程，它也有一個從產生到死亡的過程。

**新建狀態**：使用 new 關鍵字和 Thread 類或其子類建立一個執行緒物件後，該執行緒物件就處於新建狀態。它保持這個狀態直到程式 start() 這個執行緒。

**就緒狀態：**當執行緒物件呼叫了start()方法之後，該執行緒就進入就緒狀態。就緒狀態的執行緒處於就緒佇列中，要等待JVM裡執行緒排程器的排程。

**執行狀態**：如果就緒狀態的執行緒獲取 CPU 資源，就可以執行 run()，此時執行緒便處於執行狀態。處於執行狀態的執行緒最為複雜，它可以變為阻塞狀態、就緒狀態和死亡狀態。

**阻塞狀態**：如果一個執行緒執行了sleep（睡眠）、suspend（掛起）等方法，失去所佔用資源之後，該執行緒就從執行狀態進入阻塞狀態。在睡眠時間已到或獲得裝置資源後可以重新進入就緒狀態。可以分為三種：

- 等待阻塞：執行狀態中的執行緒執行 wait() 方法，使執行緒進入到等待阻塞狀態。
- 同步阻塞：執行緒在獲取 synchronized 同步鎖失敗(因為同步鎖被其他執行緒佔用)。
- 其他阻塞：透過呼叫執行緒的 sleep() 或 join() 發出了 I/O 請求時，執行緒就會進入到阻塞狀態。當sleep() 狀態超時，join() 等待執行緒終止或超時，或者 I/O 處理完畢，執行緒重新轉入就緒狀態。

**死亡狀態**：一個執行狀態的執行緒完成任務或者其他終止條件發生時，該執行緒就切換到終止狀態。

**Thread.run()和Thread.start()的區別**：

- start（）方法來啟動執行緒，真正實現了多執行緒執行。這時無需等待run方法體程式碼執行完畢，可以直接繼續執行下面的程式碼；透過呼叫Thread類的start()方法來啟動一個執行緒， 這時此執行緒是處於就緒狀態， 並沒有執行。 然後透過此Thread類呼叫方法run()來完成其執行操作的， 這裡方法run()稱為執行緒體，它包含了要執行的這個執行緒的內容， Run方法執行結束， 此執行緒終止。然後CPU再排程其它執行緒。
- run（）方法當作普通方法的方式呼叫。程式還是要順序執行，要等待run方法體執行完畢後，才可繼續執行下面的程式碼； 程式中只有主執行緒這一個執行緒， 其程式執行路徑還是隻有一條， 這樣就沒有達到寫執行緒的目的。

# 二. wait和sleep的區別

這兩個方法來自不同的類：sleep來自Thread類，而wait來自Object類。 sleep是Thread的靜態方法，誰呼叫的誰去睡覺，即使在a執行緒裡呼叫b的sleep方法，實際上還是a去睡覺，要讓b執行緒睡覺要在b的程式碼中呼叫sleep。

對鎖: 最主要是sleep方法沒有釋放鎖，而wait方法釋放了鎖，使得其他執行緒可以使用同步控制塊或者方法。　　 **sleep不出讓系統資源；wait是進入執行緒等待池等待，讓出系統資源，其他執行緒可以佔用CPU。**一般wait不會加時間限制，因為如果wait執行緒的執行資源不夠，再出來也沒用，要等待其他執行緒呼叫notify/notifyAll喚醒等待池中的所有執行緒，才會進入就緒佇列等待OS分配系統資源。sleep(milliseconds)可以用時間指定使它自動喚醒過來，如果時間不到只能呼叫interrupt()強行打斷。 Thread.sleep(0)的作用是“觸發作業系統立刻重新進行一次CPU競爭”。

使用範圍：wait，notify和notifyAll只能在同步控制方法或者同步控制塊（synchronized）裡面使用，而sleep可以在任何地方使用：
```
   synchronized(x){ 
      x.notify() 
     //或者wait() 
   }
```

# 三. 執行緒的優先順序

每一個 Java 執行緒都有一個優先順序，這樣有助於作業系統確定執行緒的排程順序。

Java 執行緒的優先順序是一個整數，其取值範圍是 1 （Thread.MIN_PRIORITY ） - 10 （Thread.MAX_PRIORITY ）。

預設情況下，每一個執行緒都會分配一個優先順序 NORM_PRIORITY（5）。

具有較高優先順序的執行緒對程式更重要，並且應該在低優先順序的執行緒之前分配處理器資源。但是，執行緒優先順序不能保證執行緒執行的順序，而且非常依賴於平臺。

# 四. 建立一個執行緒

Java 提供了三種建立執行緒的方法：

- 透過實現 Runnable 介面；
- 透過繼承 Thread 類本身；
- 透過 Callable 和 Future 建立執行緒。

**透過實現 Runnable 介面**

```
class RunnableDemo implements Runnable {
   private Thread t;
   private String threadName;
   
   RunnableDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // 讓執行緒睡眠一會
            Thread.sleep(50);
         }
      }catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}
 
public class TestThread {
 
   public static void main(String args[]) {
      RunnableDemo R1 = new RunnableDemo( "Thread-1");
      R1.start();
      
      RunnableDemo R2 = new RunnableDemo( "Thread-2");
      R2.start();
   }   
}
```

**透過繼承 Thread 類本身**
```
class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;
   
   ThreadDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // 讓執行緒睡眠一會
            Thread.sleep(50);
         }
      }catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}
 
public class TestThread {
 
   public static void main(String args[]) {
      ThreadDemo T1 = new ThreadDemo( "Thread-1");
      T1.start();
      
      ThreadDemo T2 = new ThreadDemo( "Thread-2");
      T2.start();
   }   
}
```
透過 Callable 和 Future 建立執行緒
- 建立 Callable 介面的實現類，並實現 call() 方法，該 call() 方法將作為執行緒執行體，並且有返回值。
- 建立 Callable 實現類的例項，使用 FutureTask 類來包裝 Callable 物件，該 FutureTask 物件封裝了該 Callable 物件的 call() 方法的返回值。
- 使用 FutureTask 物件作為 Thread 物件的 target 建立並啟動新執行緒。
- 呼叫 FutureTask 物件的 get() 方法來獲得子執行緒執行結束後的返回值。
```
public class CallableThreadTest implements Callable<integer> {
    public static void main(String[] args)  
    {  
        CallableThreadTest ctt = new CallableThreadTest();  
        FutureTask<integer> ft = new FutureTask<>(ctt);  
        for(int i = 0;i < 100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" 的迴圈變數i的值"+i);  
            if(i==20)  
            {  
                new Thread(ft,"有返回值的執行緒").start();  
            }  
        }  
        try  
        {  
            System.out.println("子執行緒的返回值："+ft.get());  
        } catch (InterruptedException e)  
        {  
            e.printStackTrace();  
        } catch (ExecutionException e)  
        {  
            e.printStackTrace();  
        }  
  
    }
    @Override  
    public Integer call() throws Exception  
    {  
        int i = 0;  
        for(;i<100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" "+i);  
        }  
        return i;  
    }  
}
```
**建立執行緒的三種方式的對比**

- 採用實現 Runnable、Callable 介面的方式建立多執行緒時，執行緒類只是實現了 Runnable 介面或 Callable 介面，還可以繼承其他類。
- 使用繼承 Thread 類的方式建立多執行緒時，編寫簡單，如果需要訪問當前執行緒，則無需使用 Thread.currentThread() 方法，直接使用 this 即可獲得當前執行緒。

# 五. 執行緒的幾個主要概念

在多執行緒程式設計時，你需要了解以下幾個概念：

- 執行緒同步
- 執行緒間通訊
- 執行緒死鎖
- 執行緒控制：掛起、停止和恢復

# 六. 多執行緒的使用

有效利用多執行緒的關鍵是理解程式是併發執行而不是序列執行的。例如：程式中有兩個子系統需要併發執行，這時候就需要利用多執行緒程式設計。

透過對多執行緒的使用，可以編寫出非常高效的程式。不過請注意，如果你建立太多的執行緒，程式執行的效率實際上是降低了，而不是提升了。

請記住，上下文的切換開銷也很重要，如果你建立了太多的執行緒，CPU 花費在上下文的切換的時間將多於執行程式的時間！</integer></integer>

Java常見知識點彙總（⑬）——執行緒

相關文章