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同學的分享 的文章

關鍵字: 京東 工具 Git