asyncTool 并发工具 京东开源 java 性能优化 工具

今天看了下京东开源的一个并发工具asyncTool，gitee链接为 https://gitee.com/jd-platform-opensource/asyncTool。

我git clone下来，想看看有什么玄机，结果还是很满意的。

因为之前在做公司的服务性能优化的时候，有想过通过异步的方式去获取一些数据，而不阻塞主流程，结果由于没有完整的方案，比如超时控制，线程节省等，最后还是放弃了。看完这个asyncTool之后，虽然这个还没有那么完善，但第一个版本已经能够满足大部分业务需要。

项目自带的测试代码很好，就在此基础上做注释了，源码大家可以去上面的链接中获取。下面我给大家分享下入门：

<code>DeWorker w = new DeWorker();
        DeWorker1 w1 = new DeWorker1();
        DeWorker2 w2 = new DeWorker2();

        //builder模式创建wrapper
        WorkerWrapper<workresult>, String> workerWrapper2 =  new WorkerWrapper.Builder<workresult>, String>()
                //worker为自己的IWorker, 不能为空
                .worker(w2)
                //回调为自己的ICallback, 不设置则为DefaultCallback
                .callback(w2)
                .build();

        WorkerWrapper<workresult>, User> workerWrapper1 = new WorkerWrapper.Builder<workresult>, User>()
                .worker(w1)
                .callback(w1)
                //表示当前执行完后，下一个执行的wrapper
                .next(workerWrapper2)
                .build();

        WorkerWrapper<string> workerWrapper = new WorkerWrapper.Builder<string>()
                .worker(w) 

                .param("0")
                .next(workerWrapper1)
                .callback(w)
                .build();
        //虽然尚未执行，但是也可以先取得结果的引用，作为下一个任务的入参
        WorkResult<user> result = workerWrapper.getWorkResult();
        WorkResult<user> result1 = workerWrapper1.getWorkResult();

        workerWrapper1.setParam(result);
        workerWrapper2.setParam(result1);

        //超时时间为3500毫秒，入口为workerWrapper
        Async.beginWork(3500, workerWrapper);

        System.out.println(workerWrapper2.getWorkResult());
        Async.shutDown();/<user>/<user>/<string>/<string>/<workresult>/<workresult>/<workresult>/<workresult>/<code>

这个案例是串行的，workerWrapper->workerWrapper1->workerWrapper2，和我们不用这个框架是一样的，看下运行结果，请关注下高亮部分，虽然是异步并且源码中也是有线程池的，但是这个框架对于有并行关系的wrapper，都是使用同一个线程的。

第二个案例：

<code>ParWorker w = new ParWorker();
        ParWorker1 w1 = new ParWorker1();

        ParWorker2 w2 = new ParWorker2();
        w2.setSleepTime(2000);

        ParWorker3 w3 = new ParWorker3();

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

        WorkerWrapper<string> workerWrapper3 =  new WorkerWrapper.Builder<string>()
                .worker(w3)
                .callback(w3)
                .param("3")
                .build();

        WorkerWrapper<string> workerWrapper2 =  new WorkerWrapper.Builder<string>()
                .worker(w2)
                .callback(w2)
                .param("2")
                //等workerWrapper完成后，再执行当前，底层isMust为true，表示workerWrapper对于当前wrapper是必须的前置
                .depend(workerWrapper)
                //等当前执行完成后，执行workerWrapper3，得层selfIsMust为true，表示当前wrapper对于workerWrapper3是必须的前置
                .next(workerWrapper3)
                .build();

        WorkerWrapper<string> workerWrapper1 =  new WorkerWrapper.Builder<string>()
                .worker(w1)
                .callback(w1)
                .param("1")
                //等workerWrapper完成后，再执行当前，底层isMust为true，表示workerWrapper对于当前wrapper是必须的前置
                .depend(workerWrapper)
                //等当前执行完成后，执行workerWrapper3，得层selfIsMust为true，表示当前wrapper对于workerWrapper3是必须的前置 

                .next(workerWrapper3)
                .build();

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

        //正常完毕
        Async.beginWork(4100, workerWrapper);

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

        System.out.println(Async.getThreadCount());
        Async.shutDown();/<string>/<string>/<string>/<string>/<string>/<string>/<string>/<string>/<code>

这个案例的执行顺序为0，等0完成之后，1和2都会开始，等1和2都完成之后，才会执行3

案例3，就是非必须等待

<code> WorkerWrapper<string> workerWrapper3 =  new WorkerWrapper.Builder<string>()
                .worker(w3)
                .callback(w3)
                .param("3")
                .build();

        WorkerWrapper<string> workerWrapper2 =  new WorkerWrapper.Builder<string>()
                .worker(w2)
                .callback(w2)
                .param("2")
                //workerWrapper2执行完了就执行3，但可以不执行2
                .next(workerWrapper3, false)
                .build();

        WorkerWrapper<string> workerWrapper1 =  new WorkerWrapper.Builder<string>()
                .worker(w1)
                .callback(w1)
                .param("1")
                //workerWrapper1执行完了就执行3，但可以不执行1
                .next(workerWrapper3, false)
                .build();

        WorkerWrapper<string> workerWrapper =  new WorkerWrapper.Builder<string>()
                .worker(w)
                .callback(w)
                .param("0")
                .next(workerWrapper1, workerWrapper2)
                .build();/<string>/<string>/<string>/<string>/<string>/<string>/<string>/<string>/<code>

到这里，相信大家能弄明白基本的使用了吧。

我看了底层的代码，除了原子类（AtomicInteger）来校验状态，这个完全没有锁，可以说非常实用，效率也不会低。希望这个框架能不断迭代，越来越优秀！

如果喜欢我的文章，欢迎点击订阅，这样能随时看到我的新文章！

閱讀更多 JP同學的分享 的文章

關鍵字: 开源 工具 京东商城