NIO

1. 阻塞与非阻塞
   阻塞：应用程序获取数据时，若网络传输数据很慢，程序就一直等到传输完毕为止。BIO面向流，当建立连接后传输流即同步阻塞。
   非阻塞：应用程序可直接获取已准备好的数据（如放在缓冲区中的数据）无需等待。NIO面向缓冲区，即同步非阻塞。
   IO和NIO的区别主要体现在三个方面：
   （1）IO基于流（Stream）,而NIO基于Buffer
   （2）IO操作是阻塞的，而NIO操作是非阻塞的
   （3）IO没有selector盖面，而NIO有selector概念

2. 基于Stream与基于Buffer
   传统的IO是面向字节流或字符流的，而在NIO中，我们抛弃了传统的IO流，而是引入了Channel和Buffer的概念。在NIO中，我们从Channel中读取数据到Buffer中或将数据从Buffer中写入Channel中。
   那么什么是基于流呢？在一般的java 操作中，我们以流式的方式顺序地从一个Stream中读取一个或多个字节，因此我们也就不能随意改变读取指针的位置。
   而基于Buffer就显得有点不同了。我们首先需要从Channel中读取数据到Buffer中，当Buffer中有数据后，我们就可以对这些数据进行操作了。不想IO那样是顺序操作，NIO中我们可以随意地读取任意位置的数据。

3. 同步与异步
   同步：应用程序直接参与IO读写操作，应用程序会阻塞在某一个方法上，直到数据准备就绪，或者采用轮询策略实时监测数据状态，若数据准备就绪就获取数据。
   异步：所有的IO操作都交给OS处理，与应用程序没有直接关系。当OS完成了读写操作时会给应用程序发送通知，应用程序直接拿走数据即可。

4. NIO server

public class NIOServer {

//通道管理器,相当于超级服务生,在门口迎接客人,服务客人的活全做了
private Selector selector;

/**
 * 获得一个ServerSocket通道,并对该通道做一些初始化的工作
 * */
public void initServer(int port) throws IOException {
    //获得一个ServerSocket通道
    ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    //设置通道为非阻塞
    serverSocketChannel.configureBlocking(false);
    //将该通道对应的ServerSocket绑定到port端口
    serverSocketChannel.socket().bind(new InetSocketAddress(port));
    //获得一个通道管理器
    this.selector = Selector.open();
    //将通道管理器和该通道绑定,并为该通道注册SelectionKey.OP_ACCEPT事件
    //注册该事件后,当该事件到达时selection.select()会返回.若该事件没到达selector.select()会一直阻塞
    serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
}

/**
 * 采用轮询的方式监听selector上是否有需要处理的事件,如果有,则进行处理
 * */
public void listen() throws IOException {
    System.out.println("服务端启动成功!");
    //轮询访问selector
    while(true){
        //当注册的事件到达时,方法返回.否则,该方法会一直阻塞
        selector.select();

        //获得selector中选中的项迭代器,选中的项为注册的事件
        Iterator<?> ite = this.selector.selectedKeys().iterator();
        while(ite.hasNext()){
            SelectionKey key = (SelectionKey) ite.next();
            //删除已选的key,以防重复处理
            ite.remove();
            handler(key);

        }
    }
}

public void handler(SelectionKey key) throws IOException {
    if(key.isAcceptable()){
        handlerAccept(key);
    }else if(key.isReadable()){
        handlerRead(key);
    }
}

public void handlerAccept(SelectionKey key) throws IOException {
    ServerSocketChannel server = (ServerSocketChannel) key.channel();
    //获得和客户端连接的通道
    SocketChannel channel = server.accept();
    //设置成非阻塞
    channel.configureBlocking(false);

    //在这里可以给客户端发送信息
    System.out.println("新的客户端连接");
    //在和客户端连接成功之后,为了可以接收到客户端的信息,需要给通道注册读的时间
    channel.register(this.selector,SelectionKey.OP_READ);
}

public void handlerRead(SelectionKey key) throws IOException {
    //服务器可读取消息:得到时间发生的Socket通道
    SocketChannel channel = (SocketChannel) key.channel();
    //创建读取的缓冲区
    ByteBuffer buffer = ByteBuffer.allocate(1024);
    int read = channel.read(buffer);

    if(read>0){
        byte[] data = buffer.array();
        String msg= new String(data).trim();
        System.out.println("服务端收到信息:"+msg);

        //回写数据,将消息回送给客户端
        ByteBuffer outBuffer = ByteBuffer.wrap("好的".getBytes());
        channel.write(outBuffer);
    }else{
        System.out.println("客户端关闭");
        key.cancel();
    }
}

public static void main(String[] args) throws IOException {
    NIOServer server = new NIOServer();
    server.initServer(8000);
    server.listen();
}
}

client

public class Client {

public static void main(String[] args) {
    //创建连接的地址
    InetSocketAddress address = new InetSocketAddress("localhost",8000);
    //声明连接通道
    SocketChannel sc = null;
    //建立缓冲区
    ByteBuffer buf = ByteBuffer.allocate(1024);

    try{
        //打开通道
        sc = SocketChannel.open();
        //进行连接
        sc.connect(address);

        while (true){
            //定义一个字节数组,然后使用系统录入功能
            byte[] bytes = new byte[1024];
            System.in.read(bytes);

            //把数据放到缓冲区中
            buf.put(bytes);
            //对缓冲区进行复位
            buf.flip();
            //写出数据
            sc.write(buf);
            //清空缓冲区数据
            buf.clear();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        if(sc!=null){
            try {
                sc.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
}

4. 分析
   通道管理器Selector，相当于超级服务员，在门口迎接客人，服务客人的活一个人全做了。理论上一个seletor可以对应N个客户端。即监听注册事件，又处理业务。

NIO.png

5. selector模式
   selector是NIO中才有的概念，它是 Java NIO 之所以可以非阻塞地进行IO操作的关键。
   通过Selector，一个线程可以监听多个Channel 的io事件，当我们向一个Selector中注册了Channel后，Selector内部的机制就可以自动地为我们不断地查询（select）这些注册的Channel是否有已就绪的IO事件（例如可读，可写，网络连接完成等）。通过这样的Selector机制，我们就可以很简单地使用一个县城高效地管理多个Channel了。
6. selector详细说明
   当IO事件（管道）注册到selector选择器上后，selector会为每一个管道分配一个key值，相当于标签。selector以轮询的方式进行查找注册的IO事件（管道）。当IO事件（管道）准备就绪后，selector就会识别并通过key来查找相应的管道，进行数据处理（从管道中读出或者写入数据，写到缓冲区中）。
   SelectionKey.OP_ACCEPT(16):服务器接受客户端连接事件
   SelectionKey.OP_CONNECT(8):客户端连接服务器事件
   SelectionKey.OP_READ(1):读事件
   SelectionKey.OP_WRITE(4):写事件

从理论上说一个selector可以负责任意多个Channel通道，因为JDK使用spoll替代传统的select实现，获得连接句柄没有限制。