javascript的promise.all()
promise是javascript異步編程的一種解決方案，在es6中引入。
通過promise.all()可以實現對一組異步請求的統一處理，等待所有異步執行完成之后調用回調函數。
其實，這種并發執行同步等待的需求在java并發編程中也很常見，那么，是否可以通過java也來實現這樣一個promise類呢？
使用java實現promise.all()
使用工具
countdownlatch：java并發工具包中有countdownlatch類允許一個或多個線程等待其他線程的一系列操作完成。
threadpoolexecutor：通過線程池實現多線程的并發執行
實現
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
|
public class promise { private static executorservice executorservice = executors.newscheduledthreadpool(16); private promise() { throw new assertionerror(); } /** * 實現并發同時地對某個action并發執行并返回執行結果 * 實現思路： * 并發創建所有執行的線程，并通過鎖(start)阻塞等待著 * 在創建所有執行的線程后(ready)開始計時，并解鎖然所有的線程啟動 * 通過另外一個鎖（done）記錄執行完的線程 * 主線程只需關心3點 * - 所有線程是否準備好 * - 準備好的話開始計時并解鎖開始執行 * - 等待執行完畢 * * @param callablelist 要并發執行的列表 * @return list 執行結果，list.item為null的話表示執行異常 * @throws interruptedexception 異常 */ public static <t> list<t> all(final list<callable<t>> callablelist) throws interruptedexception { final list<t> result = new arraylist<>(); int length = callablelist.size(); final countdownlatch ready = new countdownlatch(length); final countdownlatch start = new countdownlatch(1); final countdownlatch done = new countdownlatch(length); for (final callable<t> callable : callablelist) { executorservice.execute(new runnable() { @override public void run() { ready.countdown(); try { start.await(); t t = callable.call(); result.add(t); } catch (exception e) { // interrupt when exception thread.currentthread().interrupt(); // set null mean exception result.add(null); e.printstacktrace(); } finally { done.countdown(); } } }); } ready.await(); long startnano = system.nanotime(); start.countdown(); done.await(); long cause = system.nanotime() - startnano; system.out.println(string.format("promise all done,cause time millsecond: %s", cause / 1000000)); return result; }} |
效果
測試
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
public void promisealltest() throws exception{ list<callable<string>> callables = new arraylist<>(); for (int i = 0; i < 10; i++) { int finali = i; callables.add(new callable<string>() { @override public string call() throws exception { int millis = new random().nextint(10000); thread.sleep(millis); system.out.println(string.format("thread%s sleep %s millis" ,finali,millis)); return "thread" + finali; } }); } list<string> result = promise.all(callables); system.out.println(result); system.out.println("done...");} |
測試結果
thread1 sleep 732 millis
thread2 sleep 758 millis
thread7 sleep 976 millis
thread8 sleep 1397 millis
thread5 sleep 1513 millis
thread0 sleep 2221 millis
thread3 sleep 4885 millis
thread6 sleep 5221 millis
thread4 sleep 7101 millis
thread9 sleep 7634 millis
promise all done,cause time millsecond: 7638
[thread1, thread2, thread7, thread8, thread5, thread0, thread3, thread6, thread4, thread9]
done...
總結
本文只是通過原生java實現簡單版本的promise.all()，可用于簡單的并發編程，但是對于實際高并發應用還需要優化，如對線程池的優化,還有中斷的處理等。
參考
《effective java》第二版第十章第69條：并發工具優先于wait和notify
以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持服務器之家。
原文鏈接：https://www.jianshu.com/p/047a2d161f01
