Java 中實現(xiàn)異步的多種方式

更新時間：2025年03月26日 15:17:06 作者：北冥SP

文章介紹了Java中實現(xiàn)異步處理的幾種常見方式,每種方式都有其特點和適用場景,通過選擇合適的異步處理方式,可以提高程序的性能和可維護性,感興趣的朋友一起看看吧

1. 線程池（ExecutorService）

簡介：使用 ExecutorService 可以創(chuàng)建線程池來執(zhí)行異步任務。
優(yōu)點：資源復用、線程管理方便。
缺點：需要手動管理線程池的生命周期。
示例：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        Runnable task1 = () -> {
            System.out.println("Task 1 running in thread: " + Thread.currentThread().getName());
        };
        Runnable task2 = () -> {
            System.out.println("Task 2 running in thread: " + Thread.currentThread().getName());
        };
        executor.execute(task1);
        executor.execute(task2);
        executor.shutdown();
    }
}

2. CompletableFuture

簡介：CompletableFuture 是 Java 8 引入的一個強大的異步編程工具，支持鏈式調用和組合操作。
優(yōu)點：功能豐富、易于組合多個異步操作。
缺點：學習曲線較陡峭。
示例：

import java.util.concurrent.CompletableFuture;
public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture.supplyAsync(() -> {
            System.out.println("Task 1 running in thread: " + Thread.currentThread().getName());
            return "Result 1";
        }).thenApply(result -> {
            System.out.println("Task 2 running in thread: " + Thread.currentThread().getName());
            return result + " processed";
        }).thenAccept(finalResult -> {
            System.out.println("Final result: " + finalResult);
        });
        // 防止主線程提前結束
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

3. ForkJoinPool

簡介：ForkJoinPool 是一個特殊的線程池，適用于可以分解成多個子任務并行處理的場景。
優(yōu)點：適合處理大量細粒度的任務。
缺點：適用于特定類型的任務，不適用于所有異步場景。
示例：

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
public class ForkJoinExample extends RecursiveTask<Integer> {
    private final int threshold = 2;
    private final int start;
    private final int end;
    public ForkJoinExample(int start, int end) {
        this.start = start;
        this.end = end;
    }
    @Override
    protected Integer compute() {
        if (end - start <= threshold) {
            int sum = 0;
            for (int i = start; i < end; i++) {
                sum += i;
            }
            return sum;
        } else {
            int middle = (start + end) / 2;
            ForkJoinExample subtask1 = new ForkJoinExample(start, middle);
            ForkJoinExample subtask2 = new ForkJoinExample(middle, end);
            subtask1.fork();
            subtask2.fork();
            return subtask1.join() + subtask2.join();
        }
    }
    public static void main(String[] args) {
        ForkJoinPool pool = new ForkJoinPool();
        ForkJoinExample task = new ForkJoinExample(1, 100);
        int result = pool.invoke(task);
        System.out.println("Result: " + result);
    }
}

4. Callable 和Future

簡介：Callable 是一個可以返回結果并可能拋出異常的任務，Future 用于獲取 Callable 的執(zhí)行結果。
優(yōu)點：可以獲取任務的執(zhí)行結果。
缺點：需要手動管理線程和任務的生命周期。
示例：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class CallableFutureExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Callable<Integer> task = () -> {
            Thread.sleep(2000);
            return 42;
        };
        Future<Integer> future = executor.submit(task);
        try {
            Integer result = future.get();
            System.out.println("Result: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        executor.shutdown();
    }
}

5. ScheduledExecutorService

簡介：ScheduledExecutorService 是一個可以調度延遲任務和周期性任務的線程池。
優(yōu)點：適合定時任務和周期性任務。
缺點：功能相對單一。
示例：

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ScheduledExecutorExample {
    public static void main(String[] args) {
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
        Runnable task = () -> {
            System.out.println("Task running in thread: " + Thread.currentThread().getName());
        };
        // 延遲2秒后執(zhí)行任務
        scheduler.schedule(task, 2, TimeUnit.SECONDS);
        // 每隔1秒執(zhí)行一次任務
        scheduler.scheduleAtFixedRate(task, 0, 1, TimeUnit.SECONDS);
        // 防止主線程提前結束
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        scheduler.shutdown();
    }
}