接著講多線程下的其他組件，第一個要講的就是CyclicBarrier。CyclicBarrier從字面理解是指循環(huán)屏障，它可以協(xié)同多個線程，讓多個線程在這個屏障前等待，直到所有線程都達(dá)到了這個屏障時，再一起繼續(xù)執(zhí)行后面的動作。看一下CyclicBarrier的使用實例：
|
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
|
public static class CyclicBarrierThread extends Thread{ private CyclicBarrier cb; private int sleepSecond; public CyclicBarrierThread(CyclicBarrier cb, int sleepSecond) { this.cb = cb; this.sleepSecond = sleepSecond; } public void run() { try { System.out.println(this.getName() + "運行了"); Thread.sleep(sleepSecond * 1000); System.out.println(this.getName() + "準(zhǔn)備等待了, 時間為" + System.currentTimeMillis()); cb.await(); System.out.println(this.getName() + "結(jié)束等待了, 時間為" + System.currentTimeMillis()); } catch (Exception e) { e.printStackTrace(); } }} public static void main(String[] args){ Runnable runnable = new Runnable() { public void run() { System.out.println("CyclicBarrier的所有線程await()結(jié)束了，我運行了, 時間為" + System.currentTimeMillis()); } }; CyclicBarrier cb = new CyclicBarrier(3, runnable); CyclicBarrierThread cbt0 = new CyclicBarrierThread(cb, 3); CyclicBarrierThread cbt1 = new CyclicBarrierThread(cb, 6); CyclicBarrierThread cbt2 = new CyclicBarrierThread(cb, 9); cbt0.start(); cbt1.start(); cbt2.start();} |
看一下運行結(jié)果：
Thread-0運行了
Thread-2運行了
Thread-1運行了
Thread-0準(zhǔn)備等待了, 時間為1444650316313
Thread-1準(zhǔn)備等待了, 時間為1444650319313
Thread-2準(zhǔn)備等待了, 時間為1444650322313
CyclicBarrier的所有線程await()結(jié)束了，我運行了, 時間為1444650322313
Thread-2結(jié)束等待了, 時間為1444650322313
Thread-0結(jié)束等待了, 時間為1444650322313
Thread-1結(jié)束等待了, 時間為1444650322313
從運行結(jié)果看，由于是同一個CyclicBarrier，Thread-0先運行到了await()的地方，等著；Thread-2接著運行到了await()的地方，還等著；Thread-1最后運行到了await()的地方，所有的線程都運行到了await()的地方，所以三個線程以及指定的Runnable"同時"運行后面的代碼，可以看到，await()之后，四個線程運行的時間一模一樣，都是1444650322313。
從使用來看，可能有人覺得CyclicBarrier和CountDownLatch有點像，都是多個線程等待相互完成之后，再執(zhí)行后面的代碼。實際上，CountDownLatch和CyclicBarrier都是用于多個線程間的協(xié)調(diào)的，它們二者的幾個差別是：
1、CountDownLatch是在多個線程都進行了latch.countDown()后才會觸發(fā)事件，喚醒await()在latch上的線程，而執(zhí)行countDown()的線程，執(zhí)行完countDown()后會繼續(xù)自己線程的工作；CyclicBarrier是一個柵欄，用于同步所有調(diào)用await()方法的線程，線程執(zhí)行了await()方法之后并不會執(zhí)行之后的代碼，而只有當(dāng)執(zhí)行await()方法的線程數(shù)等于指定的parties之后，這些執(zhí)行了await()方法的線程才會同時運行
2、CountDownLatch不能循環(huán)使用，計數(shù)器減為0就減為0了，不能被重置；CyclicBarrier提供了reset()方法，支持循環(huán)使用
3、CountDownLatch當(dāng)調(diào)用countDown()方法的線程數(shù)等于指定的數(shù)量之后，可以喚起多條線程的任務(wù)；CyclicBarrier當(dāng)執(zhí)行await()方法的線程等于指定的數(shù)量之后，只能喚起一個BarrierAction
注意，因為使用CyclicBarrier的線程都會阻塞在await方法上，所以在線程池中使用CyclicBarrier時要特別小心，如果線程池的線程過少，那么就會發(fā)生死鎖了
Callable
Callable和Runnable差不多，兩者都是為那些其實例可能被另一個線程執(zhí)行的類而設(shè)計的，最主要的差別在于Runnable不會返回線程運算結(jié)果，Callable可以（假如線程需要返回運行結(jié)果）
Future
Future是一個接口表示異步計算的結(jié)果，它提供了檢查計算是否完成的方法，以等待計算的完成，并獲取計算的結(jié)果。Future提供了get()、cancel()、isCancel()、isDone()四種方法，表示Future有三種功能：
1、判斷任務(wù)是否完成
2、中斷任務(wù)
3、獲取任務(wù)執(zhí)行結(jié)果
FutureTask
FutureTask是Future的實現(xiàn)類，它提供了對Future的基本實現(xiàn)。可使用FutureTask包裝Callable或Runnable對象，因為FutureTask實現(xiàn)了Runnable，所以也可以將FutureTask提交給Executor。
使用方法
Callable、Future、FutureTask一般都是和線程池配合使用的，因為線程池ThreadPoolExecutor的父類AbstractExecutorService提供了三種submit方法：
1、public Future<?> subit(Runnable task){...}
2、public <T> Future<T> submit<Runnable task, T result>{...}
3、public <T> Future<T> submit<Callable<T> task>{...}
第2個用得不多，第1個和第3個比較有用
Callable+Future使用示例
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
public static class CallableThread implements Callable<String>{ public String call() throws Exception { System.out.println("進入CallableThread的call()方法, 開始睡覺, 睡覺時間為" + System.currentTimeMillis()); Thread.sleep(10000); return "123"; }} public static void main(String[] args) throws Exception{ ExecutorService es = Executors.newCachedThreadPool(); CallableThread ct = new CallableThread(); Future<String> f = es.submit(ct); es.shutdown(); Thread.sleep(5000); System.out.println("主線程等待5秒, 當(dāng)前時間為" + System.currentTimeMillis()); String str = f.get(); System.out.println("Future已拿到數(shù)據(jù), str = " + str + ", 當(dāng)前時間為" + System.currentTimeMillis());} |
運行結(jié)果為：
進入CallableThread的call()方法, 開始睡覺, 睡覺時間為1444654421368
主線程等待5秒, 當(dāng)前時間為1444654426369
Future已拿到數(shù)據(jù), str = 123, 當(dāng)前時間為1444654431369
看到任意一個利用Callable接口submit上去的任務(wù)，只要有一個Future接受它，F(xiàn)uture便可以在程序任何地點嘗試去獲取這條線程返回出去的數(shù)據(jù)，時間可以比對一下，正好10000ms，即10s
Callable+FutureTask使用示例
有興趣的可以看下源碼，其實使用Callable+Future的方式，es.submit(ct)方法返回的Future，底層實現(xiàn)new出來的是一個FutureTask。那么，我們看一下Callable+FutureTask的方式：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
public static class CallableThread implements Callable<String>{ public String call() throws Exception { System.out.println("進入CallableThread的call()方法, 開始睡覺, 睡覺時間為" + System.currentTimeMillis()); Thread.sleep(10000); return "123"; }} public static void main(String[] args) throws Exception{ ExecutorService es = Executors.newCachedThreadPool(); CallableThread ct = new CallableThread(); FutureTask<String> f = new FutureTask<String>(ct); es.submit(f); es.shutdown(); Thread.sleep(5000); System.out.println("主線程等待5秒, 當(dāng)前時間為" + System.currentTimeMillis()); String str = f.get(); System.out.println("Future已拿到數(shù)據(jù), str = " + str + ", 當(dāng)前時間為" + System.currentTimeMillis());} |
看下運行結(jié)果：
進入CallableThread的call()方法, 開始睡覺, 睡覺時間為1444655049199
主線程等待5秒, 當(dāng)前時間為1444655054200
Future已拿到數(shù)據(jù), str = 123, 當(dāng)前時間為1444655059200
和上面的寫法運行結(jié)果一樣，就不解釋了
使用Callable、Future和FutureTask的好處
上面演示了兩個例子，其實反映的是現(xiàn)實中一種情況，把上面的例子稍微擴展一下就是：
有一個method()方法，方法中執(zhí)行方法A返回一個數(shù)據(jù)要10秒鐘，A方法后面的代碼一共要執(zhí)行20秒鐘，但是這20秒的代碼中有10秒的方法并不依賴方法A的執(zhí)行結(jié)果，有10秒鐘的代碼依賴方法A的執(zhí)行結(jié)果。此時若采用同步的方式，那么勢必要先等待10秒鐘，等待方法A執(zhí)行完畢，返回數(shù)據(jù)，再執(zhí)行后面20秒的代碼。
不得不說這是一種低效率的做法。有了Callable、Future和FutureTask，那么：
1、先把A方法的內(nèi)容放到Callable實現(xiàn)類的call()方法中
2、method()方法中，Callable實現(xiàn)類傳入Executor的submit方法中
3、執(zhí)行后面方法中10秒不依賴方法A運行結(jié)果的代碼
4、獲取方法A的運行結(jié)果，執(zhí)行后面方法中10秒依賴方法A運行結(jié)果的代碼
這樣代碼執(zhí)行效率一下子就提高了，程序不必卡在A方法處。
當(dāng)然，也可以不用Callable，采用實現(xiàn)Runnable的方式，run()方法執(zhí)行完了想個辦法給method()方法中的某個變量V賦個值就好了。但是我上一篇文章開頭就說了，之所以要用多線程組件，就是因為JDK幫我們很好地實現(xiàn)好了代碼細(xì)節(jié)，讓開發(fā)者更多可以關(guān)注業(yè)務(wù)層的邏輯。如果使用Runnable的方式，那么我們自己就要考慮很多細(xì)節(jié)，比如Runnable實現(xiàn)類的run()方法執(zhí)行完畢給V賦值是否線程安全、10秒后如果A方法沒有執(zhí)行完導(dǎo)致V還沒有值怎么辦，何況JDK還給用戶提供了取消任務(wù)、判斷任務(wù)是否存在等方法。既然JDK已經(jīng)幫我們考慮并實現(xiàn)這些細(xì)節(jié)了，在沒有有說服力的理由的情況下，我們?yōu)槭裁催€要自己寫run()方法的實現(xiàn)呢？
到此這篇關(guān)于Java多線程下的其他組件之CyclicBarrier、Callable、Future和FutureTask詳解的文章就介紹到這了,更多相關(guān)Java多線程下的其他組件內(nèi)容請搜索服務(wù)器之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持服務(wù)器之家！
原文鏈接：https://www.cnblogs.com/xrq730/p/4872722.html
