多線程編程是Java中一個重要的技術點，它允許程序并行執行多個任務，從而提高程序的執行效率。本文將詳細介紹在Java中創建多線程的三種主要方法：繼承Thread類、實現Runnable接口以及使用Callable和Future接口。

1. 繼承 Thread 類

繼承Thread類是創建線程的最直接方式。通過創建一個繼承自Thread類的類，并重寫run()方法，可以將線程執行的任務放入其中。

步驟：

1. 創建一個類繼承java.lang.Thread類。
2. 重寫run()方法，將線程執行的任務放入run()方法中。
3. 創建該類的實例。
4. 調用實例的start()方法啟動線程。

示例代碼：

class MyThread extends Thread {@Overridepublic void run() {// 線程執行的任務for (int i = 0; i < 5; i++) {System.out.println("Thread running: " + i);try {Thread.sleep(1000); // 線程休眠1秒} catch (InterruptedException e) {e.printStackTrace();}}}
}public class Main {public static void main(String[] args) {MyThread thread = new MyThread();thread.start(); // 啟動線程}
}

優點：

• 簡單直接，代碼清晰。
• 適用于不需要共享資源的場景。

缺點：

• 由于Java不支持多繼承，如果繼承了Thread類，就不能繼承其他類。
• 不適用于需要共享資源的場景，因為每個線程都是獨立的Thread實例。

2. 實現 Runnable 接口

實現Runnable接口是另一種創建線程的方法，它避免了Java單繼承的限制。通過實現Runnable接口的類，并實現其run()方法，可以將線程執行的任務放入其中。

步驟：

1. 創建一個類實現java.lang.Runnable接口。
2. 實現run()方法，將線程執行的任務放入run()方法中。
3. 創建Runnable實現類的實例。
4. 創建Thread類的實例，并將Runnable實例傳遞給Thread構造函數。
5. 調用Thread實例的start()方法啟動線程。

示例代碼：

class MyRunnable implements Runnable {@Overridepublic void run() {// 線程執行的任務for (int i = 0; i < 5; i++) {System.out.println("Runnable running: " + i);try {Thread.sleep(1000); // 線程休眠1秒} catch (InterruptedException e) {e.printStackTrace();}}}
}public class Main {public static void main(String[] args) {MyRunnable myRunnable = new MyRunnable();Thread thread = new Thread(myRunnable);thread.start(); // 啟動線程}
}

優點：

• 可以實現資源共享，適用于多個線程訪問同一個資源的場景。
• 靈活性更高，因為可以通過實現接口來繼承其他類。

缺點：

• 需要額外創建一個Thread實例，代碼相對稍微復雜。

3. 使用 Callable 和 Future

如果需要在線程執行任務后獲取結果，可以使用Callable接口。與Runnable不同，Callable的call()方法可以返回結果，并且可以拋出異常。通過FutureTask類可以包裝Callable對象，并將其傳遞給Thread對象啟動線程。

步驟：

1. 創建一個類實現java.util.concurrent.Callable接口。
2. 實現call()方法，將線程執行的任務和返回結果放入call()方法中。
3. 創建Callable實現類的實例。
4. 創建FutureTask實例，并將Callable實例傳遞給FutureTask構造函數。
5. 創建Thread類的實例，并將FutureTask實例傳遞給Thread構造函數。
6. 調用Thread實例的start()方法啟動線程。
7. 調用FutureTask實例的get()方法獲取線程執行結果。

示例代碼：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;class MyCallable implements Callable<Integer> {@Overridepublic Integer call() {// 線程執行的任務int sum = 0;for (int i = 0; i < 5; i++) {sum += i;System.out.println("Callable running: " + i);try {Thread.sleep(1000); // 線程休眠1秒} catch (InterruptedException e) {e.printStackTrace();}}return sum; // 返回計算結果}
}public class Main {public static void main(String[] args) {MyCallable myCallable = new MyCallable();FutureTask<Integer> futureTask = new FutureTask<>(myCallable);Thread thread = new Thread(futureTask);thread.start(); // 啟動線程try {// 獲取線程執行結果Integer result = futureTask.get();System.out.println("Result: " + result);} catch (InterruptedException | ExecutionException e) {e.printStackTrace();}}
}

優點：

• 可以在線程任務完成后獲取返回結果。
• 可以拋出異常并進行處理。

缺點：

• 相對來說比Runnable接口實現稍微復雜一些。
• 需要額外的FutureTask來包裝Callable實例。

總結

在Java中創建多線程的方法各有優缺點，選擇哪種方法取決于具體的使用場景和需求。繼承Thread類適用于簡單的線程任務實現，而實現Runnable接口則更靈活，適用于需要共享資源的場景。使用Callable和Future接口不僅可以獲取線程執行結果，還可以處理任務執行中的異常，更適合復雜的線程任務管理。