Java 多執行緒程式設計

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

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

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

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

一個執行緒的生命週期

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

下圖顯示了一個執行緒完整的生命週期。

• 新建狀態:

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

• 就緒狀態:

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

• 執行狀態:

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

• 阻塞狀態:

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

  • 等待阻塞：執行狀態中的執行緒執行 wait() 方法，使執行緒進入到等待阻塞狀態。

  • 同步阻塞：執行緒在獲取 synchronized 同步鎖失敗(因為同步鎖被其他執行緒佔用)。

  • 其他阻塞：通過呼叫執行緒的 sleep() 或 join() 發出了 I/O 請求時，執行緒就會進入到阻塞狀態。當sleep() 狀態超時，join() 等待執行緒終止或超時，或者 I/O 處理完畢，執行緒重新轉入就緒狀態。

• 死亡狀態:

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

執行緒的優先順序

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

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

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

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

建立一個執行緒

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

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

通過實現 Runnable 介面來建立執行緒

建立一個執行緒，最簡單的方法是建立一個實現 Runnable 介面的類。

為了實現 Runnable，一個類只需要執行一個方法呼叫 run()，宣告如下：

public void run()

你可以重寫該方法，重要的是理解的 run() 可以呼叫其他方法，使用其他類，並宣告變數，就像主執行緒一樣。

在建立一個實現 Runnable 介面的類之後，你可以在類中例項化一個執行緒物件。

Thread 定義了幾個構造方法，下面的這個是我們經常使用的：

Thread(Runnable threadOb,String threadName);

這裡，threadOb 是一個實現 Runnable 介面的類的例項，並且 threadName 指定新執行緒的名字。

新執行緒建立之後，你呼叫它的 start() 方法它才會執行。

void start();

下面是一個建立執行緒並開始讓它執行的例項：

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();
   }   
}

編譯以上程式執行結果如下：

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

通過繼承Thread來建立執行緒

建立一個執行緒的第二種方法是建立一個新的類，該類繼承 Thread 類，然後建立一個該類的例項。

繼承類必須重寫 run() 方法，該方法是新執行緒的入口點。它也必須呼叫 start() 方法才能執行。

該方法儘管被列為一種多執行緒實現方式，但是本質上也是實現了 Runnable 介面的一個例項。

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();
   }   
}

編譯以上程式執行結果如下：

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

Thread 方法

下表列出了Thread類的一些重要方法：

測試執行緒是否處於活動狀態。 上述方法是被Thread物件呼叫的。下面的方法是Thread類的靜態方法。

例項

如下的ThreadClassDemo 程式演示了Thread類的一些方法：

// 檔名 : DisplayMessage.java
// 通過實現 Runnable 介面建立執行緒
public class DisplayMessage implements Runnable {
   private String message;
   
   public DisplayMessage(String message) {
      this.message = message;
   }
   
   public void run() {
      while(true) {
         System.out.println(message);
      }
   }
}

// 檔名 : GuessANumber.java
// 通過繼承 Thread 類建立執行緒
 
public class GuessANumber extends Thread {
   private int number;
   public GuessANumber(int number) {
      this.number = number;
   }
   
   public void run() {
      int counter = 0;
      int guess = 0;
      do {
         guess = (int) (Math.random() * 100 + 1);
         System.out.println(this.getName() + " guesses " + guess);
         counter++;
      } while(guess != number);
      System.out.println("** Correct!" + this.getName() + "in" + counter + "guesses.**");
   }
}

// 檔名 : ThreadClassDemo.java
public class ThreadClassDemo {
 
   public static void main(String [] args) {
      Runnable hello = new DisplayMessage("Hello");
      Thread thread1 = new Thread(hello);
      thread1.setDaemon(true);
      thread1.setName("hello");
      System.out.println("Starting hello thread...");
      thread1.start();
      
      Runnable bye = new DisplayMessage("Goodbye");
      Thread thread2 = new Thread(bye);
      thread2.setPriority(Thread.MIN_PRIORITY);
      thread2.setDaemon(true);
      System.out.println("Starting goodbye thread...");
      thread2.start();
 
      System.out.println("Starting thread3...");
      Thread thread3 = new GuessANumber(27);
      thread3.start();
      try {
         thread3.join();
      }catch(InterruptedException e) {
         System.out.println("Thread interrupted.");
      }
      System.out.println("Starting thread4...");
      Thread thread4 = new GuessANumber(75);
      
      thread4.start();
      System.out.println("main() is ending...");
   }
}

執行結果如下，每一次執行的結果都不一樣。

Starting hello thread...
Starting goodbye thread...
Hello
Hello
Hello
Hello
Hello
Hello
Goodbye
Goodbye
Goodbye
Goodbye
Goodbye
.......

通過 Callable 和 Future 建立執行緒

• 1. 建立 Callable 介面的實現類，並實現 call() 方法，該 call() 方法將作為執行緒執行體，並且有返回值。

• 2. 建立 Callable 實現類的例項，使用 FutureTask 類來包裝 Callable 物件，該 FutureTask 物件封裝了該 Callable 物件的 call() 方法的返回值。

• 3. 使用 FutureTask 物件作為 Thread 物件的 target 建立並啟動新執行緒。

• 4. 呼叫 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;  
    }  
}

建立執行緒的三種方式的對比

• 1. 採用實現 Runnable、Callable 介面的方式建立多執行緒時，執行緒類只是實現了 Runnable 介面或 Callable 介面，還可以繼承其他類。

• 2. 使用繼承 Thread 類的方式建立多執行緒時，編寫簡單，如果需要訪問當前執行緒，則無需使用 Thread.currentThread() 方法，直接使用 this 即可獲得當前執行緒。

執行緒的幾個主要概念

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

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

多執行緒的使用

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

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

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