网络I/O模型--06异步I/O

异步I/O （又称为 AIO ）则是采用“订阅一通知”工作模式 ： 即应用程序向操作系统注册I/O监听，然后继续做自己的事情。当操作系统发生I/O事件，并且准备好数据后 ， 再主动通知应用程序，触发相应的函数。

异步I/O也必须由操作系统进行支持 。 微软Windows系统提供了一种异步I/O技术 ： IOCP (I/O Completion Port, I/O完成端口〉； 多个Linux 操作系统版本（例如 CentOS 5等）下由于没有这种异步I/O技术，所以使用的是 epoll对异步I/O 进行模拟 。

但是在 Java AIO 框架中 ， 由于应用程序不是“轮询”方式，而是“订阅一通知” 方式，所以不再需要“ Selector ” （选择器）了， 改由 Channel 通道直接到操作系统注册监昕 。在 Java AIO 框架中， 只实现了两种网络 I/O 通道“ AsynchronousServerSocketChannel ”（服务器监听通道）、 “ AsynchronousSocketChannel” (Socket 套接字通道）。但是无论哪种通道它们都有独立的 fileDescriptor （文件标识符）、 attachment （附件，可以是任意对象，类似“通道上下文”），并被独立的 SocketChannelReadHandle 类实例引用 。

服务端代码

1.SocketServer6NIO

package testBlockSocket;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousChannelGroup;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.nio.channels.SelectableChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class SocketServer6NIO {
    private final static Logger LOGGER = LoggerFactory.getLogger(SocketServer6NIO.class);
    private static final Object waitObject = new Object();

    public static void main(String[] args) throws Exception {
        /*
         * 对于使用的线程池技术 : 1. Executors 是线程池生成工具，通过这个工具我们可以很轻松地生成“固定大 小的线程池”、 “调度池”、
         * “可伸缩线程数量的池”。 2. 当然你也可以通过 ThreadPoolExecutor 直接实例化线程池 3. 这个线程池是用来得到操作系统的“
         * I/O事件通知”的，不是用来进行“得到I／O数据后的业务处理的”。要进行后者的操作，你可以再使用另一个池（最好不要混用〉 4.
         * 也可以不使用线程池〈不推荐），如果决定不使用线程池，那么直接调用 AsynchronousServerSocketChannel.open()就行了
         */

        ExecutorService threadPool = Executors.newFixedThreadPool(20);
        AsynchronousChannelGroup group = AsynchronousChannelGroup.withThreadPool(threadPool);
        final AsynchronousServerSocketChannel serverSocket = AsynchronousServerSocketChannel.open(group);

        // 设置要监听的端口“0.0.0.0”代表本机所有 IP 设备
        serverSocket.bind(new InetSocketAddress("0.0.0.0", 8888));
        // 为 AsynchronousServerSocketChannel 注册监听，并不包括为随后客户端和服务器 socketChannel通道注册的监听
        serverSocket.accept(null, new ServerSocketChannelHandle(serverSocket));
        // 阻塞，以便 debug 时观察现象
        synchronized (waitObject) {
            waitObject.wait();
        }
    }
}

2.ServerSocketChannelHandle

// 这个处理器类，专门用来响应 ServerSocketChannel 的事件。ServerSocketChannel 只有一种事件 ：接收容户端的连接
class ServerSocketChannelHandle implements CompletionHandler<AsynchronousSocketChannel, Void> {
    private static final Logger LOGGER = LoggerFactory.getLogger(ServerSocketChannelHandle.class);
    private AsynchronousServerSocketChannel serverSocketChannel;

    //
    public ServerSocketChannelHandle(AsynchronousServerSocketChannel serverSocketChannel) {
        this.serverSocketChannel = serverSocketChannel;
    }

    // 注意，分别查看 this 、 socketChannel 、 attachment
    // 三个对象的ID来观察不同客户端连接到达时，这三个对象的变化，以说明ServerSocketChannelHandle 的监昕模式
    @Override
    public void completed(AsynchronousSocketChannel socketChannel, Void attachment) {
        ServerSocketChannelHandle.LOGGER.info("completed(AsynchronousSocketChannel result , ByteBuffer attachment)");
        this.serverSocketChannel.accept(attachment, this);
        // 为这个新的 SocketChannel
        // 注册“read”事件，以便操作系统在收到数据并准备好后，主动通知应用程序在这里，由于我们要将这个客户端多次传输的数据累加起来一起处理，所以将一个StringBuffer对象作为一个
        // “附件”依附在这个 Channel 上
        ByteBuffer readBuffer = ByteBuffer.allocate(50);
        socketChannel.read(readBuffer, new StringBuffer(), new SocketChannelReadHandle(socketChannel, readBuffer));
    }

    @Override
    public void failed(Throwable exc, Void attachment) {
        ServerSocketChannelHandle.LOGGER.info("failed(Throwable exc,ByteBuffer attachment)");
    }
}

3.SocketChannelReadHandle

/**
 * 负责对每一个 SocketChannel 的数据获取事件进行监听 。 重要说明 ： 每个 SocketChannel都会有一个独立工作的
 * SocketChannelReadHandle 对象(CompletionHandler 接口的实现)
 * 其中又都将独享一个“文件状态标识”对象FileDescriptor,还有一个独立的自程序员定义的 Buffer 缓存(这里我们使用的是
 * ByteBuffer),所以不用担心在服务器端会出现“窃对象”这种情况，因为 Java AIO 框架已经帮你组织好了 另 一个重要的点是，用子生成
 * Channel 的对象AsynchronousChannelProvider 是单例模式，无论在哪组 SocketChannel都是一个对象引用
 */
class SocketChannelReadHandle implements CompletionHandler<Integer, StringBuffer> {
    private static final Logger LOGGER = LoggerFactory.getLogger(SocketChannelReadHandle.class);

    private AsynchronousSocketChannel socketChannel;

    /**
     * 专门用于进行这个通道数据缓存操作的 ByteBuffer，你也可以作为 CompletionHandler的 attachment 形式传入
     */
    private ByteBuffer byteBuffer;

    public SocketChannelReadHandle(AsynchronousSocketChannel socketChannel, ByteBuffer byteBuffer) {
        this.socketChannel = socketChannel;
        this.byteBuffer = byteBuffer;
    }

    @Override
    public void completed(Integer result, StringBuffer historyContext) {
        // 如果条件成立，说明客户端主动终止了 TCP 套接字，这时服务器端终止就可以了
        if (result == -1) {
            try {
                this.socketChannel.close();
            } catch (IOException e) {
                SocketChannelReadHandle.LOGGER.error(e.getMessage());
            }
            return;
        }
        SocketChannelReadHandle.LOGGER.info("completed （integer result ,Void attachment) ：然后我们来取出通道中准备好的值");

        /*
         * 实际上，由于我们从 Integer result 知道了本次 Channel 从操作系统获取数据总长度，所以我们不需要切换成“读模式” ，
         * 但是为了保证编码的规范性，还是建议进行切换 无论是 Java AIO 框架还是 Java NIO 框架，都会出现“Buffer
         * 的总容量”小于“当前从操作系统获取到的总数据量”的情况， 但区别是， Java AIO 框架不需要专门考虑处理这样的情况，因为 Java AIO
         * 框架已经帮我们做了处理
         **/
        this.byteBuffer.flip();
        byte[] contexts = new byte[1024];
        this.byteBuffer.get(contexts, 0, result);
        this.byteBuffer.clear();
        try {
            String nowContent = new String(contexts, 0, result, "UTF-8");
            historyContext.append(nowContent);
            SocketChannelReadHandle.LOGGER.info("＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝目前的传输结果" + historyContext);
        } catch (UnsupportedEncodingException e) {
            SocketChannelReadHandle.LOGGER.error(e.getMessage());
        }

        // 如果条件成立，则说明还没有接收到“结束标记”
        if (historyContext.indexOf("over") == -1) {
            return;
        }
        // 我们以“ over ”符号作为客户端完整信息的标记
        SocketChannelReadHandle.LOGGER.info("＝＝：收到完整信息，开始处理业务-==");
        historyContext = new StringBuffer();
        // 还要继续监听（ 一次监昕一次通知）
        this.socketChannel.read(this.byteBuffer, historyContext, this);
    }

    @Override
    public void failed(Throwable exc, StringBuffer historyContext) {
        SocketChannelReadHandle.LOGGER.info("＝＝＝＝＝发现客户端异常关闭，服务器将关闭 TCP 通道 ");
        try {
            this.socketChannel.close();
        } catch (IOException e) {
            SocketChannelReadHandle.LOGGER.error(e.getMessage());

        }
    }

}

服务器处理每一个客户端通道所使用的SocketChannelReadHandle （处理器）对象都是独立的，并且所引用的 SocketChannel 对象也都是独立的。 Java NIO 和 Java AIO 框架，除了因为操作系统的实现不一样而去掉了 Selector，其他的重要概念都是相似的 。实际上 Java NIO 和 Java AIO 框架各位读者可以看成是一套完整的“高并发 I/O 处理”的实现 。