一起聊聊創建線程的八種方法
前言
在Java開發中，線程是并發編程中的核心工具。
無論是為了提高程序運行效率，還是為了處理復雜的并發任務，我們都需要在代碼中使用線程。
但如果你只知道 Thread 和 Runnable 兩種方式，那可就有點落后了。
其實，Java 提供了多種方式來創建線程，每一種都有其獨特的優勢和適用場景。
這篇文章將從淺入深，詳細剖析 Java 創建線程的8種方法，希望對你會有所幫助。
1. 繼承 Thread 類
直接繼承 Thread 類，重寫 run() 方法，將任務邏輯寫在 run() 中。
通過調用 start() 方法啟動線程。
示例代碼
class MyThread extends Thread {
@Override
public void run() {
System.out.println("線程名稱：" + Thread.currentThread().getName() + " 正在執行任務");
}
}
public class ThreadExample {
public static void main(String[] args) {
MyThread thread1 = new MyThread();
MyThread thread2 = new MyThread();
thread1.start(); // 啟動線程
thread2.start();
}
}場景解析
繼承 Thread 是最簡單的方式，非常適合初學者學習線程的基本原理。
但這種方式擴展性差，因為 Java 是單繼承語言，繼承了 Thread 后就不能再繼承其他類。
優缺點
- 優點： 簡單直觀，適合小型任務。
- 缺點： 限制了類的繼承，無法復用已有的邏輯。
2. 實現 Runnable 接口
實現 Runnable 接口，將任務邏輯寫在 run() 方法中。
通過 Thread 構造方法將 Runnable 對象傳入，啟動線程。
示例代碼
class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("線程名稱：" + Thread.currentThread().getName() + " 正在執行任務");
}
}
public class RunnableExample {
public static void main(String[] args) {
Thread thread1 = new Thread(new MyRunnable());
Thread thread2 = new Thread(new MyRunnable());
thread1.start();
thread2.start();
}
}場景解析
相比繼承 Thread，實現 Runnable 接口更靈活，避免了單繼承的限制。大多數開發場景中，更推薦使用這種方式。
優缺點
- 優點： 解耦任務邏輯和線程對象，靈活性更高。
- 缺點： 需要額外創建 Thread 對象。
3. 實現 Callable 接口
Callable 接口是 Java 5 引入的，類似于 Runnable，但它支持返回值，并可以拋出異常。
示例代碼
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
class MyCallable implements Callable<String> {
@Override
public String call() throws Exception {
return "線程名稱：" + Thread.currentThread().getName() + "，任務執行完成";
}
}
public class CallableExample {
public static void main(String[] args) throws ExecutionException, InterruptedException {
FutureTask<String> futureTask = new FutureTask<>(new MyCallable());
Thread thread = new Thread(futureTask);
thread.start();
// 獲取線程返回結果
System.out.println("線程返回結果：" + futureTask.get());
}
}場景解析
如果你的線程需要返回結果，Callable 是更好的選擇，比如數據查詢、復雜計算等場景。
優缺點
- 優點： 支持返回值和異常處理，功能更強大。
- 缺點： 代碼復雜度比 Runnable 略高。
4. 使用線程池
線程池是一種高效的線程管理機制，可以復用線程，減少創建和銷毀線程的開銷。
示例代碼
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExample {
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(3);
Runnable task = () -> System.out.println("線程名稱：" + Thread.currentThread().getName() + " 正在執行任務");
for (int i = 0; i < 5; i++) {
executorService.execute(task);
}
executorService.shutdown();
}
}場景解析
適用于需要高并發處理任務的場景，比如 Web 服務的請求處理。
優缺點
- 優點： 高效管理線程生命周期，避免頻繁創建和銷毀線程。
- 缺點： 需要合理配置線程池參數，否則可能導致資源浪費。
5. 使用 ScheduledExecutorService
ScheduledExecutorService 是 Java 提供的一種定時任務調度機制，可以在指定時間點或周期性地執行任務。
示例代碼
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ScheduledExample {
public static void main(String[] args) {
ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
Runnable task = () -> System.out.println("當前時間：" + System.currentTimeMillis());
// 延遲1秒后，每2秒執行一次
scheduler.scheduleAtFixedRate(task, 1, 2, TimeUnit.SECONDS);
// 程序運行一段時間后需要手動關閉線程池
// scheduler.shutdown();
}
}場景解析
適用于周期性任務，比如定時備份、定時清理緩存等。
優缺點
- 優點： 易于實現定時和周期性任務。
- 缺點： 不適合復雜調度場景。
6. 使用 Fork/Join 框架
Fork/Join 是 Java 7 引入的一種并行計算框架，適合將大任務分解成多個子任務并行處理。
示例代碼
import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;
class SumTask extends RecursiveTask<Integer> {
private final int start, end;
public SumTask(int start, int end) {
this.start = start;
this.end = end;
}
@Override
protected Integer compute() {
if (end - start <= 10) {
int sum = 0;
for (int i = start; i <= end; i++) {
sum += i;
}
return sum;
} else {
int mid = (start + end) / 2;
SumTask leftTask = new SumTask(start, mid);
SumTask rightTask = new SumTask(mid + 1, end);
invokeAll(leftTask, rightTask);
return leftTask.join() + rightTask.join();
}
}
}
public class ForkJoinExample {
public static void main(String[] args) {
ForkJoinPool pool = new ForkJoinPool();
SumTask task = new SumTask(1, 100);
System.out.println("總和：" + pool.invoke(task));
}
}場景解析
適合大量數據的并行處理，比如遞歸計算。
優缺點
- 優點： 提高多核 CPU 的利用率。
- 缺點： 不適合 I/O 密集型任務。
7. 使用 CompletableFuture
CompletableFuture 是 Java 8 提供的一種異步編程工具，支持鏈式調用，非常適合復雜任務的分解與組合。
示例代碼
import java.util.concurrent.CompletableFuture;
public class CompletableFutureExample {
public static void main(String[] args) {
CompletableFuture.supplyAsync(() -> {
System.out.println("任務執行：" + Thread.currentThread().getName());
return "任務結果";
}).thenApply(result -> {
System.out.println("處理結果：" + result);
return "最終結果";
}).thenAccept(System.out::println);
}
}場景解析
適用于異步任務鏈式調用，比如遠程服務調用。
優缺點
- 優點： 功能強大，代碼簡潔。
- 缺點： 學習成本較高。
8. 使用 Guava 的 ListenableFuture
Guava 提供了 ListenableFuture，對 Future 進行了增強，支持任務完成后的回調處理。
import com.google.common.util.concurrent.*;
import java.util.concurrent.Executors;
public class ListenableFutureExample {
public static void main(String[] args) {
ListeningExecutorService service = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(2));
ListenableFuture<String> future = service.submit(() -> {
Thread.sleep(1000);
return "任務完成";
});
Futures.addCallback(future, new FutureCallback<String>() {
@Override
public void onSuccess(String result) {
System.out.println("任務成功，結果：" + result);
}
@Override
public void onFailure(Throwable t) {
System.out.println("任務失敗：" + t.getMessage());
}
}, service);
service.shutdown();
}
}總結
以上就是 Java 中創建線程的 8 種方法，每一種方法都有其適用場景和優缺點。
下面給大家總結一下各自的優缺點：
方法 | 適用場景 | 優點 | 缺點 |
繼承Thread類 | 簡單任務 | 直觀易懂 | 限制了類的繼承 |
實現Runnable接口 | 大多數場景 | 靈活，不影響繼承關系 | 無返回值 |
實現Callable接口 | 返回結果或拋異常的任務 | 支持返回值 | 需要配合 |
線程池（ExecutorService） | 高并發任務 | 高效管理線程 | 配置復雜 |
ScheduledExecutorService | 周期性任務 | 易于實現定時調度 | 不適合復雜調度 |
Fork/Join框架 | 數據并行計算 | 提高多核利用率 | 不適合 I/O 密集型任務 |
CompletableFuture | 異步任務鏈式調用 | 功能強大 | 學習曲線高 |
Guava的ListenableFuture | 異步任務并帶回調 | 回調機制強大，擴展性好 | 引入了第三方依賴 |
希望大家在實際開發中，能根據場景選擇合適的方式。
比如：小任務用 Runnable，復雜計算用 Callable，高并發場景用線程池，而異步任務可以用 CompletableFuture 或 ListenableFuture等等。
通過這些方法的組合，可以讓你的代碼更加高效、優雅！
