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

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

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代表了線程執行完以后的結果，可以通過future獲得執行的結果11 //但是jdk1.8之前的Future有點雞肋，并不能實現真正的異步，需要阻塞的獲取結果，或者不斷的輪詢12 //通常我們希望當線程執行完一些耗時的任務后，能夠自動的通知我們結果，很遺憾這在原生jdk1.8之前13 //是不支持的，但是我們可以通過第三方的庫實現真正的異步回調

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 }

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

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

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 //向線程池中提交一個任務后，將會返回一個可監聽的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 //添加回調，回調由executor中的線程觸發，但也可以指定一個新的線程

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

40 //耗時任務執行失敗后回調該方法

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

46 //耗時任務執行成功后回調該方法

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

53 //主線程可以繼續做其他的工作

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

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

談到異步編程就不得不提一下Promise，很多函數式語言比如js原生支持Promise，但是在java界也有一些promise框架，其中就有大名鼎鼎的Netty。從Future、Callback到Promise甚至線程池，Netty實現了一套完整的異步框架，并且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 //向線程池中提交任務，并返回Future，該Future是netty自己實現的future20 //位于io.netty.util.concurrent包下，此處運行時的類型為PromiseTask

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

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

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

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 }

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

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實現任務異步處理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之前的實現方式

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的實現方式

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

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

以上的三種實現方式類似下面的過程：

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

總結

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

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。