# asyncTaskTool

**Repository Path**: xzjsccz/async-task-tool

## Basic Information

- **Project Name**: asyncTaskTool
- **Description**: 基于asynctool设计的异步任务调度工具， 新增任务失败重试，子任务超时时间限制，任务停止运行功能；
- **Primary Language**: Java
- **License**: MIT
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 3
- **Forks**: 0
- **Created**: 2024-11-29
- **Last Updated**: 2025-07-14

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# asyncTaskTool

#### 介绍
基于asynctool设计的异步任务调度工具， 新增任务失败重试，子任务超时时间限制，任务停止运行功能；

所有的例子均在test包下

#### 使用
基于asynctool的功能都已实现，简化任务build模块
##### WorkerWrapper对比
asynctool构建WorkerWrapper
```java
WorkerWrapper<WorkResult<User>, String> workerWrapper2 =  new WorkerWrapper.Builder<WorkResult<User>, String>()
                .worker(w2)
                .callback(w2)
                .id("third")
                .build();
```
asyncTaskTool构建WorkerWrapper
```java
 WorkerWrapper<WorkResult<User>, String> workerWrapper2 =  new WorkerWrapper<WorkResult<User>, String>()
                .worker(w2)
                .callback(w2)
                .id("third");
```
##### 任务重试功能
设置DeWorker1任务运行失败，重试3次
```java
 public User action(String object, Map<String, WorkerWrapper> allWrappers) {
        System.out.println("-----------------");
        System.out.println("获取par0的执行结果： " + allWrappers.get("first").getWorkResult());
        System.out.println("取par0的结果作为自己的入参，并将par0的结果加上一些东西");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 任务运行失败
        int a = 10/0;
        User user0 = (User) allWrappers.get("first").getWorkResult().getResult();
        return new User(user0.getName() + " worker1 add");
    }
```
```java
 WorkerWrapper<String, User> workerWrapper1 = new WorkerWrapper<String, User>()
                .worker(w1)
                .callback(w1)
                .id("second")
                .next(workerWrapper2)
                .retryCount(3);
```
运行结果
```yaml
worker0 的结果是：User{name='user0'}
-----------------
获取par0的执行结果： WorkResult{result=User{name='user0'}, resultState=SUCCESS, ex=null}
取par0的结果作为自己的入参，并将par0的结果加上一些东西
-----------------
获取par0的执行结果： WorkResult{result=User{name='user0'}, resultState=SUCCESS, ex=null}
取par0的结果作为自己的入参，并将par0的结果加上一些东西
-----------------
获取par0的执行结果： WorkResult{result=User{name='user0'}, resultState=SUCCESS, ex=null}
取par0的结果作为自己的入参，并将par0的结果加上一些东西
-----------------
获取par0的执行结果： WorkResult{result=User{name='user0'}, resultState=SUCCESS, ex=null}
取par0的结果作为自己的入参，并将par0的结果加上一些东西
worker1 的结果是：User{name='default User'}
worker2 的结果是：default
WorkResult{result=default, resultState=EXCEPTION, ex=java.util.concurrent.ExecutionException: java.lang.ArithmeticException: / by zero}
```
##### 子任务设置超时时间
设置子任务运行时间10s，子任务运行时间只有2s
```java
public User action(String object, Map<String, WorkerWrapper> allWrappers) {
        System.out.println("-----------------");
        System.out.println("获取par0的执行结果： " + allWrappers.get("first").getWorkResult());
        System.out.println("取par0的结果作为自己的入参，并将par0的结果加上一些东西");
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        User user0 = (User) allWrappers.get("first").getWorkResult().getResult();
        return new User(user0.getName() + " worker1 add");
    }
```
```java
WorkerWrapper<String, User> workerWrapper1 = new WorkerWrapper<String, User>()
                .worker(w1)
                .callback(w1)
                .id("second")
                .next(workerWrapper2)
                .timeout(2000);
```
运行结果
```yaml
worker0 的结果是：User{name='user0'}
-----------------
获取par0的执行结果： WorkResult{result=User{name='user0'}, resultState=SUCCESS, ex=null}
取par0的结果作为自己的入参，并将par0的结果加上一些东西
worker1 的结果是：User{name='default User'}
worker2 的结果是：default
WorkResult{result=default, resultState=EXCEPTION, ex=java.util.concurrent.TimeoutException}
```
##### 模拟运行中的任务停止
调用`stopWork`方法停止任务
```java
 DeWorker w = new DeWorker();
        DeWorker1 w1 = new DeWorker1();
        DeWorker2 w2 = new DeWorker2();

        WorkerWrapper<User, String> workerWrapper2 = new WorkerWrapper<User, String>()
                .worker(w2)
                .callback(w2)
                .id("third");

        WorkerWrapper<String, User> workerWrapper1 = new WorkerWrapper<String, User>()
                .worker(w1)
                .callback(w1)
                .id("second")
                .next(workerWrapper2);

        WorkerWrapper<String, User> workerWrapper = new WorkerWrapper<String, User>()
                .worker(w)
                .param("0")
                .id("first")
                .next(workerWrapper1)
                .callback(w);

        //V1.3后，不用给wrapper setParam了，直接在worker的action里自行根据id获取即可

        Thread thread = new Thread(() -> {
            try {
                Async.beginWork(35000, workerWrapper);
            } catch (ExecutionException | InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        thread.start();

        System.out.println(workerWrapper2.getWorkResult());
        
        Thread.sleep(2000);
        
        //停止任务
        Async.stopWork(workerWrapper);
      
        Async.shutDown();
```
运行结果
```yaml
WorkResult{result=null, resultState=DEFAULT, ex=null}
worker0 的结果是：User{name='user0'}
-----------------
获取par0的执行结果： WorkResult{result=User{name='user0'}, resultState=SUCCESS, ex=null}
取par0的结果作为自己的入参，并将par0的结果加上一些东西
worker2 的结果是：default
worker1 的结果是：User{name='default User'}
```