Java 實現線程池任務編排的示例代碼

更新時間：2024年10月17日 09:57:24 作者：一枚碼仔

任務編排是將多個任務按照特定的依賴關系和執(zhí)行順序進行組織和管理的過程,以確保任務能按預定邏輯順序高效執(zhí)行,本文就來介紹一下Java 實現線程池任務編排的示例代碼,感興趣的可以了解一下

1. 什么是任務編排

任務編排（Task Orchestration）是指將多個任務按照特定的依賴關系和執(zhí)行順序進行組織和管理的過程，以確保各個任務能夠按照預定的邏輯順序高效地執(zhí)行。

2. 為什么需要任務編排

在復雜的業(yè)務場景中，任務間通常存在依賴關系，也就是某個任務會依賴另一個任務的執(zhí)行結果，在這種情況下，我們需要通過任務編排，來確保任務按照正確的順序進行執(zhí)行。

在任務編排中，可以定義任務之間的依賴性、并行執(zhí)行的策略、錯誤處理機制等，從而提高整體工作流的效率和可靠性。通過任務編排，可以實現復雜業(yè)務流程的自動化管理，優(yōu)化資源利用，提高系統的靈活性與可維護性。

例如，以下任務的執(zhí)行順序：

在這里插入圖片描述

其中，任務二要等任務一執(zhí)行完才能執(zhí)行，而任務四要等任務二和任務三全部執(zhí)行完才能執(zhí)行。

3. 任務編排實現

任務編排和控制的主要手段有以下：

Future
CompletableFuture
CountDownLatch
Semaphore
CyclicBarrier

但如果是全局線程池，想要實現精準的任務編排，只能使用 Future 或 CompletableFuture。

3.1 Future 任務編排

使用 Future 實現上述 4 個任務的編排（任務二要等任務一執(zhí)行完才能執(zhí)行，而任務四要等任務二和任務三全部執(zhí)行完才能執(zhí)行）

import java.util.concurrent.*;
import java.util.Arrays;

public class TaskOrchestrator {
    public static void main(String[] args) {
        // 創(chuàng)建一個線程池來執(zhí)行任務
        ExecutorService executor = Executors.newFixedThreadPool(5);

        // 定義任務一
        Future<String> taskOneResult = executor.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                Thread.sleep(2000); // 模擬耗時操作
                return "Task One Result";
            }
        });

        // 定義任務二，依賴任務一
        Future<String> taskTwoResult = executor.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                String result = taskOneResult.get(); // 阻塞等待任務一完成
                Thread.sleep(1000); // 模擬耗時操作
                return "Task Two Result, got: " + result;
            }
        });

        // 定義任務三
        Future<String> taskThreeResult = executor.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                Thread.sleep(1500); // 模擬耗時操作
                return "Task Three Result";
            }
        });

        // 定義任務四，依賴任務二和任務三
        Future<String> taskFourResult = executor.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                String taskTwoOutput = taskTwoResult.get(); // 阻塞等待任務二完成
                String taskThreeOutput = taskThreeResult.get(); // 阻塞等待任務三完成
                Thread.sleep(500); // 模擬耗時操作
                return "Task Four Result, got: " + taskTwoOutput + " and " + taskThreeOutput;
            }
        });

        // 打印最終結果
        try {
            System.out.println("Final Result: " + taskFourResult.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

3.2 CompletableFuture 任務編排

CompletableFutrue 提供的方法有很多，但最常用和最實用的核心方法只有以下幾個：

在這里插入圖片描述

接下來，使用 CompletableFuture 實現上述 4 個任務的編排（任務二要等任務一執(zhí)行完才能執(zhí)行，而任務四要等任務二和任務三全部執(zhí)行完才能執(zhí)行）：

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureExample {

    public static void main(String[] args) {
        // 任務一：返回 "Task 1 result"
        CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> {
            try {
                // 模擬耗時操作
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException(e);
            }
            return "Task 1 result";
        });
        // 任務二：依賴任務一，返回 "Task 2 result" + 任務一的結果
        CompletableFuture<String> task2 = task1.handle((result1, throwable) -> {
            try {
                // 模擬耗時操作
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException(e);
            }
            return "Task 2 result " + result1;
        });
        // 任務三：和任務一、任務二并行執(zhí)行，返回 "Task 3 result"
        CompletableFuture<String> task3 = CompletableFuture.supplyAsync(() -> {
            try {
                // 模擬耗時操作
                Thread.sleep(800); // 任務三可能比任務二先完成
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException(e);
            }
            return "Task 3 result";
        });
        // 任務四：依賴任務二和任務三，等待它們都完成后執(zhí)行，返回 "Task 4 result" + 任務二和任務三的結果
        CompletableFuture<String> task4 = CompletableFuture.allOf(task2, task3).handle((res, throwable) -> {
            try {
                // 這里不需要顯式等待，因為 allOf 已經保證了它們完成
                return "Task 4 result with " + task2.get() + " and " + task3.get();
            } catch (InterruptedException | ExecutionException e) {
                throw new RuntimeException(e);
            }
        });
        // 獲取任務四的結果并打印
        String finalResult = task4.join();
        System.out.println(finalResult);
    }
}

到此這篇關于Java 實現線程池任務編排的示例代碼的文章就介紹到這了,更多相關Java 線程池任務編排內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: