[编织消息框架][网络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左右连接(后面会讲如何突破)