AsyncTool 京东多线程并行框架

使用

先添加repositories节点

     <repositories>
		<repository>
		    <id>jitpack.io</id>
		    <url>https://jitpack.io</url>
		</repository>
	</repositories>

然后添加如下maven依赖

      <dependency>
	    <groupId>com.gitee.jd-platform-opensource</groupId>
	    <artifactId>asyncTool</artifactId>
	    <version>V1.4-SNAPSHOT</version>
	</dependency>

基本组件

worker：

• 一个最小的任务执行单元。通常是一个网络调用，或一段耗时操作。
• T，V两个泛型，分别是入参和出参类型。
• 譬如该耗时操作，入参是String，执行完毕的结果是Integer，那么就可以用泛型来定义
• 多个不同的worker之间，没有关联，分别可以有不同的入参、出参类型

callBack：

• 对每个worker的回调。worker执行完毕后，会回调该接口，带着执行成功、失败、原始入参、和详细的结果。

wrapper：

• 组合了worker和callback，是一个 最小的调度单元 。通过编排wrapper之间的关系，达到组合各个worker顺序的目的。
• wrapper的泛型和worker的一样，决定了入参和结果的类型。

定义一个worker

public class ParWorker implements IWorker<String, String>, ICallback<String, String> {

		//	主要任务操作
        @Override
        public String action(String object, Map<String, WorkerWrapper> map) {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "result = " + SystemClock.now() + "---param = " + object + " from 0";
        }

	//任务执行异常回调
    @Override
        public String defaultValue() {
            return "worker1--default";
        }

		//	任务开始执行前的回调
        @Override
        public void begin() {
            System.out.println(Thread.currentThread().getName() + "- start --" + System.currentTimeMillis());
        }

		//任务执行完毕回调
        @Override
        public void result(boolean success, String param, WorkResult<String> workResult) {
            if (success) {
                System.out.println("callback worker0 success--" + SystemClock.now() + "----" + workResult.getResult()
                        + "-threadName:" +Thread.currentThread().getName());
            } else {
                System.err.println("callback worker0 failure--" + SystemClock.now() + "----"  + workResult.getResult()
                        + "-threadName:" +Thread.currentThread().getName());
            }
        }


}

• 通过这一个类看一下，action里就是你的耗时操作，begin就是任务开始执行时的回调，result就是worker执行完毕后的回调。当你组合了多个执行单元时，每一步的执行，都在掌控之内。失败了，还会有自定义的默认值。

实现场景

并行

以此类推创建worker1、和worker2

        ParWorker w = new ParWorker();
        ParWorker1 w1 = new ParWorker1();
        ParWorker2 w2 = new ParWorker2();

        WorkerWrapper<String, String> workerWrapper2 =  new WorkerWrapper.Builder<String, String>()
                .worker(w2)
                .callback(w2)
                .param("2")
                .build();

        WorkerWrapper<String, String> workerWrapper1 =  new WorkerWrapper.Builder<String, String>()
                .worker(w1)
                .callback(w1)
                .param("1")
                .build();

        WorkerWrapper<String, String> workerWrapper =  new WorkerWrapper.Builder<String, String>()
                .worker(w)
                .callback(w)
                .param("0")
                .build();

        long now = SystemClock.now();
        System.out.println("begin-" + now);

        Async.beginWork(1500, workerWrapper, workerWrapper1, workerWrapper2);
//        Async.beginWork(800, workerWrapper, workerWrapper1, workerWrapper2);
//        Async.beginWork(1000, workerWrapper, workerWrapper1, workerWrapper2);

        System.out.println("end-" + SystemClock.now());
        System.err.println("cost-" + (SystemClock.now() - now));
        System.out.println(Async.getThreadCount());

        System.out.println(workerWrapper.getWorkResult());
        Async.shutDown();
       

如此，实现了线程的并行

串、并行

可以通过一下方法实现

//下一个要执行的线程
.next()

//在哪个线程之后执行
.depend()

通过以上两个方法可以实现线程之间的串、并行等各种复杂的操作

例如实现一下操作

依赖别的worker执行结果作为入参

首先通过 .id(“id”) 方法想要获取参数的线程都编号，

然后在worker类中通过get(“id”)的方法，获取指定id的返回结果作为参数
通过.getWorkResult().getResult()获取具体的返回值

结果如下