JDK7 AIO初體驗實例

原文地址：JDK7 AIO初體驗實例 做者：鄭君華

from: http://www.iteye.com/topic/1113611

JDK7已經release一段時間了，有個重要的新特性是AIO。
今天趁閒暇，簡單體驗了下，簡單分享以下：

關於AIO的概念理解 
關於AIO的概念，僅談談我的的一點理解。可能不到位，請你們指出。
Io的兩個重要步驟：發起IO請求，和實際的IO操做。在unix網絡編程的定義裏異步和非異步概念的區別就是實際的IO操做是否阻塞。若是不是就是異步，若是是就是同步。
而阻塞和非阻塞的區別在於發起IO請求的時候是否會阻塞，若是會就是阻塞，不會就是非阻塞。

本人理解能力有限，想了個例子來輔助本身理解：
小明想要買一本<深刻java虛擬機>的書，如下幾個場景能夠來理解這幾種io模式：
1.   若是小明天天都去書店問售貨員說有沒有這本書，若是沒有就回去繼續等待，等下次再過來文。(阻塞)
2.   若是小明告訴售貨員想買一本<深刻java虛擬機>的書，那麼就在家裏等着作其餘事情去了，若是書到了售貨員就通知小明，小明再本身過去取。
3.   若是小明告售貨員想買一本<深刻java虛擬機>的書，而後告訴售貨員到了幫他送到某某地方去，就作其餘事情去了。小明就無論了，等書到了，售貨員就幫他送到那個地方了。


售貨員能夠認爲是操做系統的一個服務，而小明是一個用戶進程。不知道是否有誤，若是有誤請你們拍磚指出，謝謝。
能夠看出2,3的效率明顯要比1高。可是1最簡單，而2,3須要一些協做。充分證實了團隊合做的力量。

JDK7AIO初體驗 
AsynchronousChannel：支持異步通道，包括服務端AsynchronousServerSocketChannel和普通AsynchronousSocketChannel等實現。
CompletionHandler：用戶處理器。定義了一個用戶處理就緒事件的接口，由用戶本身實現，異步io的數據就緒後回調該處理器消費或處理數據。
AsynchronousChannelGroup：一個用於資源共享的異步通道集合。處理IO事件和分配給CompletionHandler。(具體這塊還沒細看代碼，後續再分析這塊)

以一個簡單監聽服務端爲例，基本過程是： 
1.   啓動一個服務端通道
2.   定義一個事件處理器，用戶事件完成的時候處理，如消費數據。
3.   向系統註冊一個感興趣的事件，如接受數據，並把事件完成的處理器傳遞給系統。
4.   都已經交待完畢，能夠只管繼續作本身的事情了，操做系統在完成事件後經過其餘的線程會自動調用處理器完成事件處理。

如下用一個例子來簡單實現，一個服務端和客戶端。服務端監聽客戶端的消息，並打印出來。

AIOServer.java

Java代碼 

1. package io.aio;  
2.   
3. import java.io.IOException;  
4. import java.net.InetSocketAddress;  
5. import java.nio.ByteBuffer;  
6. import java.nio.channels.AsynchronousServerSocketChannel;  
7. import java.nio.channels.AsynchronousSocketChannel;  
8. import java.nio.channels.CompletionHandler;  
9. import java.util.concurrent.ExecutionException;  
10. import java.util.concurrent.Future;  
11. import java.util.concurrent.TimeUnit;  
12. import java.util.concurrent.TimeoutException;  
13.   
14.   
15. public class AIOServer {  
16.     public final static int PORT = 9888;  
17.     private AsynchronousServerSocketChannel server;  
18.   
19.     public AIOServer() throws IOException {  
20.         server = AsynchronousServerSocketChannel.open().bind(  
21.                 new InetSocketAddress(PORT));  
22.     }  
23.   
24.     public void startWithFuture() throws InterruptedException,  
25.             ExecutionException, TimeoutException {  
26.         System.out.println("Server listen on " + PORT);  
27.         Future<AsynchronousSocketChannel> future = server.accept();  
28.         AsynchronousSocketChannel socket = future.get();  
29.         ByteBuffer readBuf = ByteBuffer.allocate(1024);  
30.         readBuf.clear();  
31.         socket.read(readBuf).get(100, TimeUnit.SECONDS);  
32.         readBuf.flip();  
33.         System.out.printf("received message:" + new String(readBuf.array()));  
34.         System.out.println(Thread.currentThread().getName());  
35.   
36.     }  
37.   
38.     public void startWithCompletionHandler() throws InterruptedException,  
39.             ExecutionException, TimeoutException {  
40.         System.out.println("Server listen on " + PORT);  
41.         //註冊事件和事件完成後的處理器  
42.         server.accept(null,  
43.                 new CompletionHandler<AsynchronousSocketChannel, Object>() {  
44.                     final ByteBuffer buffer = ByteBuffer.allocate(1024);  
45.   
46.                     public void completed(AsynchronousSocketChannel result,  
47.                             Object attachment) {  
48.                         System.out.println(Thread.currentThread().getName());  
49.                         System.out.println("start");  
50.                         try {  
51.                             buffer.clear();  
52.                             result.read(buffer).get(100, TimeUnit.SECONDS);  
53.                             buffer.flip();  
54.                             System.out.println("received message: "  
55.                                     + new String(buffer.array()));  
56.                         } catch (InterruptedException | ExecutionException e) {  
57.                             System.out.println(e.toString());  
58.                         } catch (TimeoutException e) {  
59.                             e.printStackTrace();  
60.                         } finally {  
61.   
62.                             try {  
63.                                 result.close();  
64.                                 server.accept(null, this);  
65.                             } catch (Exception e) {  
66.                                 System.out.println(e.toString());  
67.                             }  
68.                         }  
69.   
70.                         System.out.println("end");  
71.                     }  
72.   
73.                     @Override  
74.                     public void failed(Throwable exc, Object attachment) {  
75.                         System.out.println("failed: " + exc);  
76.                     }  
77.                 });  
78.         // 主線程繼續本身的行爲  
79.         while (true) {  
80.             System.out.println("main thread");  
81.             Thread.sleep(1000);  
82.         }  
83.   
84.     }  
85.   
86.     public static void main(String args[]) throws Exception {  
87.         new AIOServer().startWithCompletionHandler();  
88.     }  
89. }  

 

AIOClient.java

Java代碼   

1. package io.aio;  
2.   
3. import java.net.InetSocketAddress;  
4. import java.nio.ByteBuffer;  
5. import java.nio.channels.AsynchronousSocketChannel;  
6.   
7. public class AIOClient {  
8.   
9.     public static void main(String... args) throws Exception {  
10.         AsynchronousSocketChannel client = AsynchronousSocketChannel.open();  
11.         client.connect(new InetSocketAddress("localhost", 9888));  
12.         client.write(ByteBuffer.wrap("test".getBytes())).get();  
13.     }  
14. }  

 

服務端寫了兩種處理實現方式，startWithCompletionHandler是經過Handler來處理，startWithFuture是經過Future方式來處理。startWithCompletionHandler方法裏能夠看到調用accepte()完成異步註冊後，線程就能夠繼續本身的處理了，徹底不被這個io所中斷。

從以上來看AIO的代碼簡單了不少，至少比NIO的代碼實現簡單不少。