java AIO示例

BIO：同步阻塞IO操作、NIO：同步非阻塞IO操作、AIO：异步非阻塞IO操作。

NIO通过监听请求，处理请求，之后返回结果，属于同步操作。AIO监听请求，后台应用程序处理请求（这个时候监听器继续监听请求），回调结果。后端的应用只是处理等待队列中的请求，这样请求处理和执行任务就分离了，实现异步操作。

AIO是异步IO的缩写，虽然NIO在网络操作中，提供了非阻塞的方法，但是NIO的IO行为还是同步的。对于NIO来说，我们的业务线程是在IO操作准备好时，得到通知，接着就由这个线程自行进行IO操作，IO操作本身是同步的。

但是对AIO来说，则更加进了一步，它不是在IO准备好时再通知线程，而是在IO操作已经完成后，再给线程发出通知。因此AIO是不会阻塞的，此时我们的业务逻辑将变成一个回调函数，等待IO操作完成后，由系统自动触发。

下面的程序是通过AIO来实现一个简单的EchoServer以及对应的客户端。

在AIO socket编程中，服务端通道是AsynchronousServerSocketChannel，这个类提供了一个open()静态工厂，一个bind()方法用于绑定服务端IP地址（还有端口号），另外还提供了accept()用于接收用户连接请求。在客户端使用的通道是AsynchronousSocketChannel,这个通道处理提供open静态工厂方法外，还提供了read和write方法。

在AIO编程中，发出一个事件（accept read write等）之后要指定事件处理类（回调函数），AIO中的事件处理类是CompletionHandler<V,A>，这个接口定义了如下两个方法，分别在异步操作成功和失败时被回调。

   void completed(Vresult, Aattachment);

   void failed(Throwableexc, Aattachment);

说了这么多，感觉很像Ajax中的回调方法，只不过换成了类。直接看代码吧：

服务端：

[java] view plain copy

print?

1. import java.io.IOException;  
2. import java.net.InetSocketAddress;  
3. import java.nio.ByteBuffer;  
4. import java.nio.channels.AsynchronousServerSocketChannel;  
5. import java.nio.channels.AsynchronousSocketChannel;  
6. import java.nio.channels.CompletionHandler;  
7. import java.util.concurrent.ExecutionException;  
8. import java.util.concurrent.Future;  
9. import java.util.concurrent.TimeUnit;  
10. import java.util.concurrent.TimeoutException;  
11.   
12. public class AIOEchoServer {  
13.   
14.     public final static int PORT = 8001;  
15.     public final static String IP = "127.0.0.1";  
16.   
17.       
18.     private AsynchronousServerSocketChannel server = null;  
19.       
20.     public AIOEchoServer(){  
21.         try {  
22.             //同样是利用工厂方法产生一个通道，异步通道 AsynchronousServerSocketChannel  
23.             server = AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(IP,PORT));  
24.         } catch (IOException e) {  
25.             e.printStackTrace();  
26.         }  
27.     }  
28.       
29.     //使用这个通道(server)来进行客户端的接收和处理  
30.     public void start(){  
31.         System.out.println("Server listen on "+PORT);  
32.           
33.         //注册事件和事件完成后的处理器，这个CompletionHandler就是事件完成后的处理器  
34.         server.accept(null,new CompletionHandler<AsynchronousSocketChannel,Object>(){  
35.   
36.             final ByteBuffer buffer = ByteBuffer.allocate(1024);  
37.               
38.             @Override  
39.             public void completed(AsynchronousSocketChannel result,Object attachment) {  
40.                   
41.                 System.out.println(Thread.currentThread().getName());  
42.                 Future<Integer> writeResult = null;  
43.                   
44.                 try{  
45.                     buffer.clear();  
46.                     result.read(buffer).get(100,TimeUnit.SECONDS);  
47.                       
48.                     System.out.println("In server: "+ new String(buffer.array()));  
49.                       
50.                     //将数据写回客户端  
51.                     buffer.flip();  
52.                     writeResult = result.write(buffer);  
53.                 }catch(InterruptedException | ExecutionException | TimeoutException e){  
54.                     e.printStackTrace();  
55.                 }finally{  
56.                     server.accept(null,this);  
57.                     try {  
58.                         writeResult.get();  
59.                         result.close();  
60.                     } catch (InterruptedException | ExecutionException e) {  
61.                         e.printStackTrace();  
62.                     } catch (IOException e) {  
63.                         e.printStackTrace();  
64.                     }  
65.                 }  
66.                   
67.             }  
68.   
69.             @Override  
70.             public void failed(Throwable exc, Object attachment) {  
71.                 System.out.println("failed:"+exc);  
72.             }  
73.               
74.         });  
75.     }  
76.       
77.     public static void main(String[] args) {  
78.         new AIOEchoServer().start();  
79.         while(true){  
80.             try {  
81.                 Thread.sleep(1000);  
82.             } catch (InterruptedException e) {  
83.                 e.printStackTrace();  
84.             }  
85.         }  
86.     }  
87.   
88. }  

import java.io.IOException;import java.net.InetSocketAddress;import java.nio.ByteBuffer;import java.nio.channels.AsynchronousServerSocketChannel;import java.nio.channels.AsynchronousSocketChannel;import java.nio.channels.CompletionHandler;import java.util.concurrent.ExecutionException;import java.util.concurrent.Future;import java.util.concurrent.TimeUnit;import java.util.concurrent.TimeoutException;public class AIOEchoServer {public final static int PORT = 8001;public final static String IP = "127.0.0.1";private AsynchronousServerSocketChannel server = null;public AIOEchoServer(){try {//同样是利用工厂方法产生一个通道，异步通道 AsynchronousServerSocketChannelserver = AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(IP,PORT));} catch (IOException e) {e.printStackTrace();}}//使用这个通道(server)来进行客户端的接收和处理public void start(){System.out.println("Server listen on "+PORT);//注册事件和事件完成后的处理器，这个CompletionHandler就是事件完成后的处理器server.accept(null,new CompletionHandler<AsynchronousSocketChannel,Object>(){final ByteBuffer buffer = ByteBuffer.allocate(1024);@Overridepublic void completed(AsynchronousSocketChannel result,Object attachment) {System.out.println(Thread.currentThread().getName());Future<Integer> writeResult = null;try{buffer.clear();result.read(buffer).get(100,TimeUnit.SECONDS);System.out.println("In server: "+ new String(buffer.array()));//将数据写回客户端buffer.flip();writeResult = result.write(buffer);}catch(InterruptedException | ExecutionException | TimeoutException e){e.printStackTrace();}finally{server.accept(null,this);try {writeResult.get();result.close();} catch (InterruptedException | ExecutionException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}}}@Overridepublic void failed(Throwable exc, Object attachment) {System.out.println("failed:"+exc);}});}public static void main(String[] args) {new AIOEchoServer().start();while(true){try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}}

客户端：

[java] view plain copy

print?

1. import java.io.IOException;  
2. import java.net.InetSocketAddress;  
3. import java.nio.ByteBuffer;  
4. import java.nio.channels.AsynchronousSocketChannel;  
5. import java.nio.channels.CompletionHandler;  
6.   
7. public class AIOClient {  
8.   
9.     public static void main(String[] args) throws IOException {  
10.           
11.         final AsynchronousSocketChannel client = AsynchronousSocketChannel.open();  
12.           
13.         InetSocketAddress serverAddress = new InetSocketAddress("127.0.0.1",8001);  
14.           
15.         CompletionHandler<Void, ? super Object> handler = new CompletionHandler<Void,Object>(){  
16.   
17.             @Override  
18.             public void completed(Void result, Object attachment) {  
19.                 client.write(ByteBuffer.wrap("Hello".getBytes()),null,   
20.                         new CompletionHandler<Integer,Object>(){  
21.   
22.                             @Override  
23.                             public void completed(Integer result,  
24.                                     Object attachment) {  
25.                                 final ByteBuffer buffer = ByteBuffer.allocate(1024);  
26.                                 client.read(buffer,buffer,new CompletionHandler<Integer,ByteBuffer>(){  
27.   
28.                                     @Override  
29.                                     public void completed(Integer result,  
30.                                             ByteBuffer attachment) {  
31.                                         buffer.flip();  
32.                                         System.out.println(new String(buffer.array()));  
33.                                         try {  
34.                                             client.close();  
35.                                         } catch (IOException e) {  
36.                                             e.printStackTrace();  
37.                                         }  
38.                                     }  
39.   
40.                                     @Override  
41.                                     public void failed(Throwable exc,  
42.                                             ByteBuffer attachment) {  
43.                                     }  
44.                                       
45.                                 });  
46.                             }  
47.   
48.                             @Override  
49.                             public void failed(Throwable exc, Object attachment) {  
50.                             }  
51.                       
52.                 });  
53.             }  
54.   
55.             @Override  
56.             public void failed(Throwable exc, Object attachment) {  
57.             }  
58.               
59.         };  
60.           
61.         client.connect(serverAddress, null, handler);  
62.         try {  
63.             Thread.sleep(1000);  
64.         } catch (InterruptedException e) {  
65.             e.printStackTrace();  
66.         }  
67.     }  
68.   
69. }  

import java.io.IOException;import java.net.InetSocketAddress;import java.nio.ByteBuffer;import java.nio.channels.AsynchronousSocketChannel;import java.nio.channels.CompletionHandler;public class AIOClient {public static void main(String[] args) throws IOException {final AsynchronousSocketChannel client = AsynchronousSocketChannel.open();InetSocketAddress serverAddress = new InetSocketAddress("127.0.0.1",8001);CompletionHandler<Void, ? super Object> handler = new CompletionHandler<Void,Object>(){@Overridepublic void completed(Void result, Object attachment) {client.write(ByteBuffer.wrap("Hello".getBytes()),null, new CompletionHandler<Integer,Object>(){@Overridepublic void completed(Integer result,Object attachment) {final ByteBuffer buffer = ByteBuffer.allocate(1024);client.read(buffer,buffer,new CompletionHandler<Integer,ByteBuffer>(){@Overridepublic void completed(Integer result,ByteBuffer attachment) {buffer.flip();System.out.println(new String(buffer.array()));try {client.close();} catch (IOException e) {e.printStackTrace();}}@Overridepublic void failed(Throwable exc,ByteBuffer attachment) {}});}@Overridepublic void failed(Throwable exc, Object attachment) {}});}@Overridepublic void failed(Throwable exc, Object attachment) {}};client.connect(serverAddress, null, handler);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}