[编织消息框架][网络IO模型]aio

asynchronous I/O (the POSIX aio_functions)—————异步IO模型最大的特点是 完成后发回通知。

与NIO不同，当进行读写操作时，只须直接调用API的read或write方法即可。这两种方法均为异步的，对于读操作而言，当有流可读取时，操作系统会将可读的流传入read方法的缓冲区，并通知应用程序；对于写操作而言，当操作系统将write方法传递的流写入完毕时，操作系统主动通知应用程序。

即可以理解为，accept,connect,read,write方法都是异步的，完成后会主动调用回调函数。 
在JDK1.7中，这部分内容被称作NIO.2，主要在java.nio.channels包下增加了下面四个异步通道：

• AsynchronousSocketChannel
• AsynchronousServerSocketChannel
• AsynchronousFileChannel
• AsynchronousDatagramChannel

其中的accept,connect,read,write方法，会返回一个带回调函数的对象，当执行完读取/写入操作后，直接调用回调函数。

 public class ClientAio implements Runnable {
     private final static int count = 50000;
     private final static AsynchronousSocketChannel[] clients = new AsynchronousSocketChannel[count];
     private final static AtomicInteger ai = new AtomicInteger();

     private String host;
     private int port;
     private AsynchronousSocketChannel client;

     public ClientAio(String host, int port) throws IOException {
         this.client = AsynchronousSocketChannel.open();
         this.host = host;
         this.port = port;
     }

     public static void main(String[] args) throws Exception {
         String addr = args.length > 0 ? args[0] : "192.168.56.122";
         while (ai.get() < count) {
             new ClientAio(addr, 8989).run();
         }
         System.in.read();
     }

     public void run() {
         client.connect(new InetSocketAddress(host, port), null, new CompletionHandler<Void, Object>() {
             public void completed(Void result, Object attachment) {
                 int i = ai.getAndIncrement();
                 if (i < count) {
                     clients[i] = client;
                 }
                 final ByteBuffer byteBuffer = ByteBuffer.allocate(512);
                 client.read(byteBuffer, null, new CompletionHandler<Integer, Object>() {
                     public void completed(Integer result, Object attachment) {

                         //System.out.println("client read data: " + new String(byteBuffer.array()));
                     }

                     public void failed(Throwable exc, Object attachment) {
                         System.out.println("read faield");
                     }
                 });
             }

             public void failed(Throwable exc, Object attachment) {
                 System.out.println("client connect field...");
                 try {
                     if(client.isOpen()){
                      client.close();
                     }
                 } catch (IOException e) {
                 }
             }
         });
     }
 }

 public class ServerAio implements Runnable {
     private final static AtomicInteger ai = new AtomicInteger();
     private int port = 8889;
     private int threadSize = 10;
     private AsynchronousChannelGroup asynchronousChannelGroup;
     private AsynchronousServerSocketChannel serverChannel;

     public ServerAio(int port, int threadSize) {
         this.port = port;
         this.threadSize = threadSize;
     }

     public static void main(String[] args) throws IOException {
         new ServerAio(8989, Runtime.getRuntime().availableProcessors() * 10).run();
         System.in.read();
     }

     public void run() {
         try {
             asynchronousChannelGroup = AsynchronousChannelGroup.withCachedThreadPool(Executors.newCachedThreadPool(), threadSize);
             serverChannel = AsynchronousServerSocketChannel.open(asynchronousChannelGroup);
             serverChannel.bind(new InetSocketAddress(port));
             System.out.println("listening on port: " + port);
             serverChannel.accept(this, new CompletionHandler<AsynchronousSocketChannel, ServerAio>() {

                 public void completed(AsynchronousSocketChannel result, ServerAio attachment) {
                     try {
                         System.out.println(ai.getAndIncrement());
                         ByteBuffer echoBuffer = ByteBuffer.allocateDirect(1024);
                         result.read(echoBuffer, null, new CompletionHandler<Integer, Object>() {
                             @Override
                             public void completed(Integer result, Object attachment) {
                             // System.out.println("received : " +
                             // Charset.defaultCharset().decode(echoBuffer));
                             }

                             @Override
                             public void failed(Throwable exc, Object attachment) {
                             }
                         });

                         result.write(ByteBuffer.wrap("ok".getBytes()));
                     } catch (Exception e) {
                         e.printStackTrace();
                     } finally {
                         attachment.serverChannel.accept(attachment, this);// 监听新的请求，递归调用。
                     }
                 }

                 public void failed(Throwable exc, ServerAio attachment) {
                     System.out.println("received failed");
                     exc.printStackTrace();
                     attachment.serverChannel.accept(attachment, this);// 监听新的请求，递归调用。
                 }
             });

         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 }

AIO与NIO对比，减少read阻塞等侍时间，速度非常之快，本人在window环境下测试瓶颈1.6W左右连接(后面会讲如何突破)