java多线程任务编排

序

在java里有很多高并并发和多线程的工具高，本身没也可以实现任务编排，但是代码量和复用性很差，要考虑的事情很多，一旦遗漏就会出现异常，最近也在做这样的task，也借机会，开发了一个小的工具包，增加了复用性，代码也简单。
源码也已经放在 https://github.com/yanghaiji/AsyncTask，目前这个项目在开发中，也希望有兴趣的朋友一起加入

AsyncTask

AsyncTask是Java并发工具包的扩展，它提供了一种简便的方式来管理和调度多线程执行的任务。
其主要功能是在多线程环境下，简化任务之间的依赖关系，从而使得开发者能够将更多的精力集中在业务逻辑的实现上，
而非任务调度的复杂性。通过使用 AsyncTask，开发者可以更加高效地处理并发任务，提高程序的性能和响应速度，
同时也降低了多线程编程的难度和风险。

参考手册

Worker

通过Worker创建任务,同时可以指定失败之后的回调，让我们进行异常的处理

• 示例

    // 创建任务
    Worker<Integer, Integer> taskA = new Worker<>("A", () -> {
        sleep(1000);
        return 1;
    },
        @Override
        public Integer onFailure(Throwable t) {
            System.out.println("Task A failed with exception: " + t.getMessage());
            return -1;
        }
    });

TaskScheduler

核心的任务编排工具，包括了任务的添加，运行，编排任务，等待其它任务完成后在执行当前任务

 TaskScheduler scheduler = new TaskScheduler(4); 

 TaskScheduler schedulerAndShutdown = new SchedulerBuilder()
            .setThreadPoolSize(20)
            .addTask(taskA, 1000)
            .addTask(taskB, 2000)
            .addTask(taskC, 2000)
            .addTask(taskD, 2000)
            .runTask("A", 3000)
            .runTask("B", 3000)
            .runTaskAfter("C", 3000, "A", "B")
            .runTaskAfterWithResult("D", resultMap -> {
                // 使用resultMap处理结果
                return 5;
            }, 4000, "C")
            .buildAndShutdown();

完整示例

public static void main(String[] args) {
        TaskScheduler scheduler = new TaskScheduler(4);  // 设置线程池大小为4

        // 创建任务
        Worker<Integer, Integer> taskA = new Worker<>("A", () -> {
            sleep(1000);
            return 1;
        }, new ICallback<Integer, Integer>() {
            @Override
            public void callback(Integer result) {
            }

            @Override
            public Integer onFailure(Throwable t) {
                System.out.println("Task A failed with exception: " + t.getMessage());
                return -1;
            }
        });

        Worker<Integer, Integer> taskE = new Worker<>("E", () -> {
            sleep(1000);
            return 2;
        }, new ICallback<Integer, Integer>() {
            @Override
            public void callback(Integer result) {
            }

            @Override
            public Integer onFailure(Throwable t) {
                System.out.println("Task E failed with exception: " + t.getMessage());
                return -1;
            }
        });

        Worker<Integer, Integer> taskB = new Worker<>("B", () -> {
            sleep(1000);
            return 3 / 0;  // 模拟异常
        }, new ICallback<Integer, Integer>() {
            @Override
            public void callback(Integer result) {
            }

            @Override
            public Integer onFailure(Throwable t) {
                return -1;
            }
        });

        Worker<Integer, Integer> taskC = new Worker<>("C", () -> {
            sleep(1000);
            return 4;
        }, new ICallback<Integer, Integer>() {
            @Override
            public void callback(Integer result) {
            }

            @Override
            public Integer onFailure(Throwable t) {
                System.out.println("Task C failed with exception: " + t.getMessage());
                return -1;
            }
        });

        Worker<Integer, Integer> taskD = new Worker<>("D", () -> {
            sleep(1000);
            return 5;
        }, new ICallback<Integer, Integer>() {
            @Override
            public void callback(Integer result) {
            }

            @Override
            public Integer onFailure(Throwable t) {
                System.out.println("Task D failed with exception: " + t.getMessage());
                return -1;
            }
        });

        // 添加任务
        scheduler.addTask(taskA, 2000);
        scheduler.addTask(taskE, 2000);
        scheduler.addTask(taskB, 2000);
        scheduler.addTask(taskC, 2000);
        scheduler.addTask(taskD, 2000);

        // 执行任务，注意顺序和依赖
        scheduler.runTask("A", 2000);
        scheduler.runTask("E", 2000);
        scheduler.runTaskAfter("B", 2000, "A");
        scheduler.runTaskAfter("C", 2000, "E");
        scheduler.runTaskAfter("D", 2000, "B", "C");

        scheduler.allOf("A", "B", "C", "D", "E");

        // 打印任务状态
        // 获取任务状态
        System.out.println("Task A status: " + scheduler.getTaskStatus("A") +" results : " + taskA.getResult());
        System.out.println("Task E status: " + scheduler.getTaskStatus("E") +" results : " + taskE.getResult());
        System.out.println("Task B status: " + scheduler.getTaskStatus("B") +" results : " + taskB.getResult());
        System.out.println("Task C status: " + scheduler.getTaskStatus("C") +" results : " + taskC.getResult());
        System.out.println("Task D status: " + scheduler.getTaskStatus("D") +" results : " + taskD.getResult());

        // 关闭任务调度器
        scheduler.shutdown();
        System.out.println("All tasks are completed");
    }

更多的使用方式请参考 https://github.com/yanghaiji/AsyncTask/tree/main/src/test/java/com/javayh/async/task