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