在Java開發(fā)中，線程是并發(fā)編程中的核心工具。

無論是為了提高程序運(yùn)行效率，還是為了處理復(fù)雜的并發(fā)任務(wù)，我們都需要在代碼中使用線程。

但如果你只知道 Thread 和 Runnable 兩種方式，那可就有點(diǎn)落后了。

其實(shí)，Java 提供了多種方式來創(chuàng)建線程，每一種都有其獨(dú)特的優(yōu)勢和適用場景。

這篇文章將從淺入深，詳細(xì)剖析 Java 創(chuàng)建線程的8種方法，每種方法都會(huì)附帶示例代碼和場景解析，幫你徹底掌握線程的創(chuàng)建與管理，希望對你會(huì)有所幫助。

(我最近開源了一個(gè)基于 SpringBoot+Vue+uniapp 的商城項(xiàng)目，歡迎訪問和star。)[https://gitee.com/dvsusan/susan_mall]

1. 繼承 Thread 類

直接繼承 Thread 類，重寫 run() 方法，將任務(wù)邏輯寫在 run() 中。

通過調(diào)用 start() 方法啟動(dòng)線程。

示例代碼

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(); // 啟動(dòng)線程
        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 對象傳入，啟動(dòng)線程。

示例代碼

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ù)雜計(jì)算等場景。

優(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 提供的一種定時(shí)任務(wù)調(diào)度機(jī)制，可以在指定時(shí)間點(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)前時(shí)間：" + System.currentTimeMillis());

        // 延遲1秒后，每2秒執(zhí)行一次
        scheduler.scheduleAtFixedRate(task, 1, 2, TimeUnit.SECONDS);

        // 程序運(yùn)行一段時(shí)間后需要手動(dòng)關(guān)閉線程池
        // scheduler.shutdown();
    }
}

場景解析

適用于周期性任務(wù)，比如定時(shí)備份、定時(shí)清理緩存等。

優(yōu)缺點(diǎn)

• 優(yōu)點(diǎn)： 易于實(shí)現(xiàn)定時(shí)和周期性任務(wù)。
• 缺點(diǎn)： 不適合復(fù)雜調(diào)度場景。

6. 使用 Fork/Join 框架

Fork/Join 是 Java 7 引入的一種并行計(jì)算框架，適合將大任務(wù)分解成多個(gè)子任務(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ù)的并行處理，比如遞歸計(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)：

希望大家在實(shí)際開發(fā)中，能根據(jù)場景選擇合適的方式。

比如：小任務(wù)用 Runnable，復(fù)雜計(jì)算用 Callable，高并發(fā)場景用線程池，而異步任務(wù)可以用 CompletableFuture 或 ListenableFuture等等。

通過這些方法的組合，可以讓你的代碼更加高效、優(yōu)雅！

注：本文轉(zhuǎn)載自“蘇三說技術(shù)”，如有侵權(quán)，請聯(lián)系刪除！