很多時候我們都希望能夠最大的利用資源，比如在進(jìn)行IO操作的時候盡可能的避免同步阻塞的等待，因為這會浪費CPU的資源。如果在有可讀的數(shù)據(jù)的時候能夠通知程序執(zhí)行讀操作甚至由操作系統(tǒng)內(nèi)核幫助我們完成數(shù)據(jù)的拷貝，這再好不過了。從NIO到CompletableFuture、Lambda、Fork/Join，java一直在努力讓程序盡可能變的異步甚至擁有更高的并行度，這一點一些函數(shù)式語言做的比較好，因此java也或多或少的借鑒了某些特性。下面介紹一種非常常用的實現(xiàn)異步操作的方式。

考慮有一個耗時的操作，操作完后會返回一個結(jié)果(不管是正常結(jié)果還是異常)，程序如果想擁有比較好的性能不可能由線程去等待操作的完成，而是應(yīng)該采用listener模式。jdk并發(fā)包里的Future代表了未來的某個結(jié)果，當(dāng)我們向線程池中提交任務(wù)的時候會返回該對象。代碼例子：

1 /**

2 * jdk1.8之前的Future3 *4 *@authorAdministrator5 *6 */

7 public classJavaFuture {8 public static void main(String[] args) throwsThrowable, ExecutionException {9 ExecutorService executor = Executors.newFixedThreadPool(1);10 //Future代表了線程執(zhí)行完以后的結(jié)果，可以通過future獲得執(zhí)行的結(jié)果11 //但是jdk1.8之前的Future有點雞肋，并不能實現(xiàn)真正的異步，需要阻塞的獲取結(jié)果，或者不斷的輪詢12 //通常我們希望當(dāng)線程執(zhí)行完一些耗時的任務(wù)后，能夠自動的通知我們結(jié)果，很遺憾這在原生jdk1.8之前13 //是不支持的，但是我們可以通過第三方的庫實現(xiàn)真正的異步回調(diào)

14 Future f = executor.submit(new Callable() {15

16 @Override17 public String call() throwsException {18 System.out.println("task started!");19 Thread.sleep(3000);20 System.out.println("task finished!");21 return "hello";22 }23 });24

25 //此處阻塞main線程

26 System.out.println(f.get());27 System.out.println("main thread is blocked");28 }29 }

如果想獲得耗時操作的結(jié)果，可以通過get方法獲取，但是該方法會阻塞當(dāng)前線程，我們可以在做完剩下的某些工作的時候調(diào)用get方法試圖去獲取結(jié)果，也可以調(diào)用非阻塞的方法isDone來確定操作是否完成，這種方式有點兒類似下面的過程：

這種方式對流程的控制很混亂，但是在jdk1.8之前只提供了這種笨拙的實現(xiàn)方式，以至于很多高性能的框架都實現(xiàn)了自己的一套異步框架，比如Netty和Guava，下面分別介紹下這三種異步的實現(xiàn)方式(包括jdk1.8)。首先是Guava中的實現(xiàn)方式：

1 packageguava;2

3 importjava.util.concurrent.Callable;4 importjava.util.concurrent.ExecutorService;5 importjava.util.concurrent.Executors;6

7 importcom.google.common.util.concurrent.FutureCallback;8 importcom.google.common.util.concurrent.Futures;9 importcom.google.common.util.concurrent.ListenableFuture;10 importcom.google.common.util.concurrent.ListeningExecutorService;11 importcom.google.common.util.concurrent.MoreExecutors;12

13 /**

14 * Guava中的Future15 *16 *@authorAdministrator17 *18 */

19 public classGuavaFuture {20 public static voidmain(String[] args) {21 ExecutorService executor = Executors.newFixedThreadPool(1);22

23 //使用guava提供的MoreExecutors工具類包裝原始的線程池

24 ListeningExecutorService listeningExecutor =MoreExecutors.listeningDecorator(executor);25 //向線程池中提交一個任務(wù)后，將會返回一個可監(jiān)聽的Future，該Future由Guava框架提供

26 ListenableFuture lf = listeningExecutor.submit(new Callable() {27

28 @Override29 public String call() throwsException {30 System.out.println("task started!");31 //模擬耗時操作

32 Thread.sleep(3000);33 System.out.println("task finished!");34 return "hello";35 }36 });37 //添加回調(diào)，回調(diào)由executor中的線程觸發(fā)，但也可以指定一個新的線程

38 Futures.addCallback(lf, new FutureCallback() {39

40 //耗時任務(wù)執(zhí)行失敗后回調(diào)該方法

41 @Override42 public voidonFailure(Throwable t) {43 System.out.println("failure");44 }45

46 //耗時任務(wù)執(zhí)行成功后回調(diào)該方法

47 @Override48 public voidonSuccess(String s) {49 System.out.println("success " +s);50 }51 });52

53 //主線程可以繼續(xù)做其他的工作

54 System.out.println("main thread is running");55 }56 }

Guava提供了一套完整的異步框架，核心是可監(jiān)聽的Future，通過注冊監(jiān)聽器或者回調(diào)方法實現(xiàn)及時獲取操作結(jié)果的能力。需要提一點的是，假設(shè)添加監(jiān)聽的時候耗時操作已經(jīng)執(zhí)行完了，此時回調(diào)方法會被立即執(zhí)行并不會丟失。想探究其實現(xiàn)方式的話可以跟一下源碼，底層的原理并不難。

談到異步編程就不得不提一下Promise，很多函數(shù)式語言比如js原生支持Promise，但是在java界也有一些promise框架，其中就有大名鼎鼎的Netty。從Future、Callback到Promise甚至線程池，Netty實現(xiàn)了一套完整的異步框架，并且netty代碼中也大量使用了Promise，下面是Netty中的例子：

1 packagenetty_promise;2

3 importio.netty.util.concurrent.DefaultEventExecutorGroup;4 importio.netty.util.concurrent.EventExecutorGroup;5 importio.netty.util.concurrent.Future;6 importio.netty.util.concurrent.FutureListener;7

8 /**

9 * netty中的promise10 *11 *@authorAdministrator12 *13 */

14 public classPromiseTest {15 @SuppressWarnings({ "unchecked", "rawtypes"})16 public static void main(String[] args) throwsThrowable {17 //線程池

18 EventExecutorGroup group = new DefaultEventExecutorGroup(1);19 //向線程池中提交任務(wù)，并返回Future，該Future是netty自己實現(xiàn)的future20 //位于io.netty.util.concurrent包下，此處運行時的類型為PromiseTask

21 Future> f = group.submit(newRunnable() {22

23 @Override24 public voidrun() {25 System.out.println("任務(wù)正在執(zhí)行");26 //模擬耗時操作，比如IO操作

27 try{28 Thread.sleep(1000);29 } catch(InterruptedException e) {30 e.printStackTrace();31 }32 System.out.println("任務(wù)執(zhí)行完畢");33 }34 });35 //增加監(jiān)聽

36 f.addListener( newFutureListener() {37 @Override38 public void operationComplete(Future arg0) throwsException {39 System.out.println("ok!!!");40 }41 });42 System.out.println("main thread is running.");43 }44 }

直到j(luò)dk1.8才算真正支持了異步操作，其中借鑒了某些框架的實現(xiàn)思想，但又有新的功能，同時在jdk1.8中提供了lambda表達(dá)式，使得java向函數(shù)式語言又靠近了一步。借助jdk原生的CompletableFuture可以實現(xiàn)異步的操作，同時結(jié)合lambada表達(dá)式大大簡化了代碼量。代碼例子如下：

1 packagenetty_promise;2

3 importjava.util.concurrent.CompletableFuture;4 importjava.util.concurrent.ExecutionException;5 importjava.util.concurrent.ExecutorService;6 importjava.util.concurrent.Executors;7 importjava.util.function.Supplier;8

9 /**

10 * 基于jdk1.8實現(xiàn)任務(wù)異步處理11 *12 *@authorAdministrator13 *14 */

15 public classJavaPromise {16 public static void main(String[] args) throwsThrowable, ExecutionException {17 //兩個線程的線程池

18 ExecutorService executor = Executors.newFixedThreadPool(2);19 //jdk1.8之前的實現(xiàn)方式

20 CompletableFuture future = CompletableFuture.supplyAsync(new Supplier() {21 @Override22 publicString get() {23 System.out.println("task started!");24 try{25 //模擬耗時操作

26 Thread.sleep(2000);27 } catch(InterruptedException e) {28 e.printStackTrace();29 }30 return "task finished!";31 }32 }, executor);33

34 //采用lambada的實現(xiàn)方式

35 future.thenAccept(e -> System.out.println(e + " ok"));36

37 System.out.println("main thread is running");38 }39 }

以上的三種實現(xiàn)方式類似下面的過程：

上面的圖只是簡單的表示了一下異步的實現(xiàn)流程，實際的調(diào)用中看似順序的步驟會發(fā)生線程的切換。

總結(jié)

以上是生活随笔為你收集整理的java event 异步_[转]java异步编程的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。