AIO 详解

AIO（Asynchronous Input and Output）

异步IO则采用“订阅-通知”模式：
	即应用程序向操作系统注册IO监听，然后继续做自己的事情。
	当操作系统发生IO事件，并且准备好数据后，在主动通知应用程序，触发相应的函数

NIO在网络操作中，提供了非阻塞的方法，但是NIO的IO行为还是同步的。
NIO的业务线程是在IO操作准备好时，得到通知，接着就由这个线程自行进行IO操作（IO操作本身是同步的）

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

基本操作

与NIO不同，当进行读写操作时，AIO只须直接调用API的read或write方法即可。

两种方法均为异步的：

	对于读操作而言，当有流可读取时，操作系统会将可读的流传入read方法的缓冲区，并通知应用程序；

	对于写操作而言，当操作系统将write方法传递的流写入完毕时，操作系统主动通知应用程序。 

	即可以理解为，read/write方法都是异步的，完成后会主动调用回调函数。

在JDK1.7中，这部分内容被称作NIO2，主要在Java.nio.channels包下增加了下面四个异步通道：

	AsynchronousSocketChannel

	AsynchronousServerSocketChannel

	AsynchronousFileChannel

	AsynchronousDatagramChannel

在AIO socket编程中，服务端通道是AsynchronousServerSocketChannel：

	open()静态工厂：
        	public static AsynchronousServerSocketChannel open(AsynchronousChannelGroup group)
        	public static AsynchronousServerSocketChannel open()
        	如果参数是null，则由系统默认提供程序创建resulting channel，并且绑定到默认组

	bind()方法用于绑定服务端IP地址（还有端口号）。

	accept()用于接收用户连接请求。

	AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(PORT);

	public abstract <A> void accept(A attachment,CompletionHandler<AsynchronousSocketChannel,? super A> handler);

	public abstract Future<AsynchronousSocketChannel> accept();

在客户端使用的通道是AsynchronousSocketChannel：

	这个通道处理提供open静态工厂方法外，还提供了read和write方法。

	public abstract Future<Void> connect(SocketAddress remote);
	Future对象的get()方法会阻塞该线程，所以这种方式是阻塞式的异步IO

	public abstract <A> void connect(SocketAddress remote,
        	                             A attachment,
           	                          CompletionHandler<Void,? super A> handler);

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

	void completed(V result, A attachment);    //第一个参数代表IO操作返回的对象，第二个参数代表发起IO操作时传入的附加参数

	void failed(Throwable exc, A attachment);    //第一个参数代表IO操作失败引发的异常或错误

异步channel API提供了两种方式监控/控制异步操作(connect,accept, read，write等)：

	第一种方式是返回java.util.concurrent.Future对象，
	检查Future的状态可以得到操作是否完成还是失败，还是进行中（future.get()阻塞当前进程以判断IO操作完成）

	第二种方式为操作提供一个回调参数java.nio.channels.CompletionHandler
	这个回调类包含completed,failed两个方法。

Future方式（异步阻塞）

Future是在JDK1.5中加入Java并发包的，该接口提供get()方法用于获取任务完成之后的处理结果。

在AIO中，可以接受一个I/O连接请求，返回一个Future对象。

然后可以基于该返回对象进行后续的操作，包括使其阻塞、查看是否完成、超时异常。

使用异步Channel时，accept()、connect()、read()、write()等方法都不会阻塞，

也就是说如果使用返回Future的这些方法，程序并不能直到什么时候成功IO，

必须要使用get方法，等get方法的阻塞结束后才能确保IO完成，继续执行下面的操作。

FutureClient

public class ClientOnFuture {
    static final int PORT = 10000;
    static final String IP = "localhost";
    static ByteBuffer buffer = ByteBuffer.allocateDirect(1024);

    public static void main(String[] args) {
        //尝试创建AsynchronousSocketChannel
        try (AsynchronousSocketChannel socketChannel = AsynchronousSocketChannel.open()) {
            //获取连接
            Future<Void> connect = socketChannel.connect(new InetSocketAddress(IP, PORT));
            //返回连接状态
            Void aVoid = connect.get();
            //返回null表示连接成功
            if (aVoid == null) {
                /**
                 * 向服务端发送数据
                 */
                Future<Integer> write = socketChannel.write(ByteBuffer.wrap("客户端说：我连接成功了！".getBytes()));
                Integer integer = write.get();
                System.out.println("服务端接收的字节长度：" + integer);
                /**
                 * 接收服务端数据
                 */
                while (socketChannel.read(buffer).get() != -1) {
                    buffer.flip();
                    CharBuffer decode = Charset.defaultCharset().decode(buffer);
                    System.out.println(decode.toString());
                    if (buffer.hasRemaining()) {
                        buffer.compact();
                    } else {
                        buffer.clear();
                    }
                    int r = new Random().nextInt(10);
                    if (r == 5) {
                        System.out.println("客户端关闭！");
                        break;
                    } else {
                        /**
                         * 如果在频繁调用write()的时候，在上一个操作没有写完的情况下，
                         * 调用write会触发WritePendingException异常
                         *
                         * 应此此处最好在调用write()之后调用get()阻塞以便确认io操作完成
                         */
                        socketChannel.write(ByteBuffer.wrap(("客户端发送的数据:" + r).getBytes())).get();
                    }
                }
            } else {
                System.out.println("无法建立连接!");
            }
        } catch (Exception e) {
            System.out.println("出错了！");
        }
    }
}

FutureServer

public class ServerOnFuture {
    static final int PORT = 10000;
    static final String IP = "localhost";
    static ByteBuffer buffer = ByteBuffer.allocateDirect(1024);

    public static void main(String[] args) {
        try (AsynchronousServerSocketChannel serverSocketChannel = AsynchronousServerSocketChannel.open()) {
            serverSocketChannel.bind(new InetSocketAddress(IP, PORT));
            while (true) {
                Future<AsynchronousSocketChannel> channelFuture = serverSocketChannel.accept();
                try (AsynchronousSocketChannel socketChannel = channelFuture.get()) {
                    while (socketChannel.read(buffer).get() != -1) {
                        buffer.flip();
                        /**
                         * 此处要注意：千万不能直接操作buffer（因为write要用到buffer），否则客户端会阻塞并报错
                         *     “java.util.concurrent.ExecutionException: java.io.IOException: 指定的网络名不再可用。”
                         *
                         * 缓冲区的复制有分两种：
                         *      1、完全复制：调用duplicate()函数或者asReadOnlyBuffer()函数
                         *      2、部分复制：调用slice函数
                         *
                         * duplicate()函数创建了一个与原始缓冲区相似的新缓冲区。
                         *      每个缓冲区有自己的位置信息，但对缓冲区的修改都会映射到同一个底层数组上。
                         */
                        //复制一个缓冲区会创建一个新的 Buffer 对象，但并不复制数据。原始缓冲区和副本都会操作同样的数据元素。
                        ByteBuffer duplicate = buffer.duplicate();
                        CharBuffer decode = Charset.defaultCharset().decode(duplicate);
                        System.out.println("收到客户端数据：" + decode);

                        /**
                         * 写回数据(get()会阻塞以等待io操作完成)
                         */
                        socketChannel.write(buffer).get();

                        /**
                         * 清理buffer，准备下一次read
                         */
                        if (buffer.hasRemaining()) {
                            /**
                             * 如果未写完，表示buffer还有数据，则只清理写过的数据
                             * compact()方法只会清除已经读过的数据。
                             * 任何未读的数据都被移到缓冲区的起始处，新写入的数据将放到缓冲区未读数据的后面。
                             */
                            buffer.compact();
                        } else {
                            buffer.clear();
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Future方式实现多客户端并发

public class ServerOnFuture {
    static final int PORT = 10000;
    static final String IP = "localhost";
    //无界线程池
    static ExecutorService taskExecutorService = Executors.newCachedThreadPool();
    static ByteBuffer buffer = ByteBuffer.allocateDirect(1024);

    public static void main(String[] args) {
        try (AsynchronousServerSocketChannel serverSocketChannel = AsynchronousServerSocketChannel.open()) {
            serverSocketChannel.bind(new InetSocketAddress(IP, PORT));
            while (true) {
                Future<AsynchronousSocketChannel> socketChannelFuture = serverSocketChannel.accept();
                try {
                    final AsynchronousSocketChannel socketChannel = socketChannelFuture.get();
                    /**
                     * 创建一个具有回调的线程
                     */
                    Callable<String> worker = new Callable<String>() {
                        @Override
                        public String call() throws Exception {
                            while (socketChannel.read(buffer).get() != -1) {
                                buffer.flip();
                                ByteBuffer duplicate = buffer.duplicate();
                                CharBuffer decode = Charset.defaultCharset().decode(duplicate);
                                System.out.println(decode.toString());
                                socketChannel.write(buffer).get();
                                if (buffer.hasRemaining()) {
                                    buffer.compact();
                                } else {
                                    buffer.clear();
                                }
                            }
                            socketChannel.close();
                            return "服务端反馈信息：收到";
                        }
                    };
                    /**
                     * 将线程提交到线程池
                     */
                    taskExecutorService.submit(worker);
                    //获取线程数
                    System.out.println(((ThreadPoolExecutor) taskExecutorService).getActiveCount());
                } catch (InterruptedException | ExecutionException e) {
                    /**
                     * 出现异常，关闭线程池
                     */
                    taskExecutorService.shutdown();
                    /**
                     * boolean isTerminated()
                     *      若关闭后所有任务都已完成，则返回true。
                     *      注意除非首先调用shutdown或shutdownNow，否则isTerminated永不为true。
                     */
                    while (!taskExecutorService.isTerminated()) {
                    }
                    //跳出循环，结束程序
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

异步非阻塞和Group

AsynchronousChannelGroup是异步Channel的分组管理器，它可以实现资源共享。

创建AsynchronousChannelGroup时，需要传入一个ExecutorService，也就是绑定一个线程池。

该线程池负责两个任务：处理IO事件和触发CompletionHandler回调接口。

每个异步通道都必须关联一个组，要么是系统默认组，要么是用户创建的组。

如果不使用group参数，java使用一个默认的系统范围的组对象。

异步IO模型中，用户线程直接使用内核提供的异步IO API发起read请求。

发起后立即返回，继续执行用户线程代码。

此时用户线程已经将调用的AsynchronousOperation和CompletionHandler注册到内核，然后操作系统开启独立的内核线程去处理IO操作。

当read请求的数据到达时，由内核负责读取socket中的数据，并写入用户指定的缓冲区中。

最后内核将read的数据和用户线程注册的CompletionHandler分发给内部Proactor，Proactor将IO完成的信息通知给用户线程（一般通过调用用户线程注册的完成事件处理函数），完成异步IO。

Callback方式客户端（异步非阻塞）

public class ClientOnCompletionHandler {
    static final int PORT = 10000;
    static final String IP = "localhost";

    public static void main(String[] args) {
        try (final AsynchronousSocketChannel socketChannel = AsynchronousSocketChannel.open()) {
            socketChannel.connect(new InetSocketAddress(IP, PORT), null, new CompletionHandler<Void, Void>() {
                final ByteBuffer buffer = ByteBuffer.allocateDirect(1024);

                @Override
                public void completed(Void result, Void attachment) {
                    try {
                        socketChannel.write(ByteBuffer.wrap("Hello Server！".getBytes())).get();
                        while (socketChannel.read(buffer).get() != -1) {
                            buffer.flip();
                            ByteBuffer duplicate = buffer.duplicate();
                            CharBuffer decode = Charset.defaultCharset().decode(duplicate);
                            System.out.println(decode.toString());
                            buffer.clear();
                            int r = new Random().nextInt(10);
                            socketChannel.write(ByteBuffer.wrap("客户端消息：".concat(String.valueOf(r)).getBytes())).get();
                            Thread.sleep(3000);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        try {
                            socketChannel.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }

                @Override
                public void failed(Throwable exc, Void attachment) {
                    System.out.println("连接失败！");
                }
            });

            //主要是阻塞作用，因为AIO是异步的，所以此处不阻塞的话，主线程很快执行完毕，并会关闭通道
            System.in.read();

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

Callback方式服务端（异步非阻塞）

public class ServerOnCompletionHandler {
    static final int PORT = 10000;
    static final String IP = "localhost";

    public static void main(String[] args) {
        //打开通道
        try (final AsynchronousServerSocketChannel serverSocketChannel = AsynchronousServerSocketChannel.open()) {
            //创建服务
            serverSocketChannel.bind(new InetSocketAddress(IP, PORT));
            //接收客户端连接
            serverSocketChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
                final ByteBuffer buffer = ByteBuffer.allocateDirect(1024);

                @Override
                public void completed(AsynchronousSocketChannel socketChannel, Void attachment) {
                    /**
                     * 注意接收一个连接之后，紧接着可以接收下一个连接，所以必须再次调用accept方法
                     * AsynchronousSocketChannel就代表该CompletionHandler处理器在处理连接成功时的result（AsynchronousSocketChannel的实例）
                     */
                    serverSocketChannel.accept(null, this);
                    try {
                        while (socketChannel.read(buffer).get() != -1) {
                            buffer.flip();
                            final ByteBuffer duplicate = buffer.duplicate();
                            final CharBuffer decode = Charset.defaultCharset().decode(duplicate);
                            System.out.println(decode.toString());
                            socketChannel.write(buffer).get();  //get()用于阻塞使IO操作完成
                            if (buffer.hasRemaining()) {
                                buffer.compact();
                            } else {
                                buffer.clear();
                            }
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        try {
                            socketChannel.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }

                @Override
                public void failed(Throwable exc, Void attachment) {
                    /**
                     * 失败后也需要接收下一个连接
                     */
                    serverSocketChannel.accept(null, this);
                    System.out.println("连接失败！");
                }
            });

            //主要是阻塞作用，因为AIO是异步的，所以此处不阻塞的话，主线程很快执行完毕，并会关闭通道
            System.in.read();

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

自定义Group

public class ServerOnReaderAndWriterForMultiClients {
    static final int PORT = 10000;
    static final String IP = "localhost";
    static AsynchronousChannelGroup threadGroup = null;
    static ExecutorService executorService = Executors.newCachedThreadPool();

    public static void main(String[] args) {
        try {
            threadGroup = AsynchronousChannelGroup.withCachedThreadPool(executorService, 5);
            //或者使用指定数量的线程池
            //threadGroup = AsynchronousChannelGroup.withFixedThreadPool(5, Executors.defaultThreadFactory());
        } catch (IOException e) {
            e.printStackTrace();
        }

        try (AsynchronousServerSocketChannel serverSocketChannel = AsynchronousServerSocketChannel.open(threadGroup)) {
            serverSocketChannel.bind(new InetSocketAddress(IP, PORT));
            serverSocketChannel.accept(serverSocketChannel, new CompletionHandler<AsynchronousSocketChannel, AsynchronousServerSocketChannel>() {
                final ByteBuffer buffer = ByteBuffer.allocateDirect(1024);

                @Override
                public void completed(AsynchronousSocketChannel socketChannel, AsynchronousServerSocketChannel attachment) {
                    serverSocketChannel.accept(null, this);
                    try {
                        while (socketChannel.read(buffer).get() != -1) {
                            buffer.flip();
                            final ByteBuffer duplicate = buffer.duplicate();
                            final CharBuffer decode = Charset.defaultCharset().decode(duplicate);
                            System.out.println(decode.toString());
                            socketChannel.write(buffer).get();  //get()用于阻塞使IO操作完成
                            if (buffer.hasRemaining()) {
                                buffer.compact();
                            } else {
                                buffer.clear();
                            }
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        try {
                            socketChannel.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }

                @Override
                public void failed(Throwable exc, AsynchronousServerSocketChannel attachment) {
                    serverSocketChannel.accept(null, this);
                    System.out.println("连接失败！");
                }
            });

            //此方法一直阻塞，直到组终止、超时或当前线程中断
            threadGroup.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}