Java之NIO、主从Reactor

1. NIO 基本介绍

① Java NIO 全称java non-blocking IO，是同步非阻塞的

② NIO有三大核心部分: Channel(通道),Buffer(缓冲区), Selector(选择器)

1. 每个 Channel 都会对应一个Buffer
2. Selector 对应一个线程， 一个Selector 可以有多个 Channel(连接)注册
3. Selector调用select()开始监听，调用selectedKeys()获取关注的事件的集合；如果是accept请求建立连接请求，就为该client生成一个SocketChannel，然后关联一个Buffer，最后将SocketChannel注册到Selector，
4. Selector 会根据不同的事件，在各个通道上切换
5. Buffer 就是一个内存块 ， 底层是有一个数组
6. 数据的读取写入是通过 Buffer, 这个和BIO不同（BIO 中是输入流\输出流, 不能双向），NIO的 Buffer 是可读可写的，只需 flip 方法切换
   

④ Java NIO 的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据，如果目前没有数据还处于准备阶段（无数据可用），就什么都不会获取，也不会保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。非阻塞写也是如此，一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。

⑤ 通俗理解：NIO是可以做到用一个线程来处理多个操作的。假设有10000个请求过来,根据实际情况，可以分配50或者100个线程来处理。不像之前的阻塞IO那样，非得分配10000个。

⑥ HTTP2.0使用了多路复用的技术，做到同一个连接并发处理多个请求（数量也比HTTP1.1多）

2. NIO原理

NIO Server：

public class NIOServer {
    public static void main(String[] args) throws Exception{

        //创建ServerSocketChannel -> ServerSocket
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

        //得到一个Selecor对象
        Selector selector = Selector.open();

        //绑定一个端口6666, 在服务器端监听
        serverSocketChannel.socket().bind(new InetSocketAddress(6666));
        //设置为非阻塞
        serverSocketChannel.configureBlocking(false);

        //把 serverSocketChannel 注册到  selector 关心 事件为 OP_ACCEPT
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("注册后的selectionkey 数量=" + selector.keys().size()); // 1

        //循环等待客户端连接
        while (true) {
            //这里我们等待1秒，如果没有事件发生, 返回
            if(selector.select(1000) == 0) { //没有事件发生
                System.out.println("服务器等待了1秒，无连接");
                continue;
            }
            // 如果返回的>0,就获取selectionKey集合（表示已经获取到关注的事件）
            // selector.selectedKeys() 返回关注事件的集合
            Set<SelectionKey> selectionKeys = selector.selectedKeys();

            //遍历 Set<SelectionKey>, 使用迭代器遍历
            Iterator<SelectionKey> keyIterator = selectionKeys.iterator();
            while (keyIterator.hasNext()) {
                //获取到SelectionKey
                SelectionKey key = keyIterator.next();
                //根据key 对应的通道发生的事件做相应处理
                if(key.isAcceptable()) { //如果是 OP_ACCEPT, 有新的客户端连接
                    //该该客户端生成一个 SocketChannel
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    System.out.println("客户端连接成功 生成了一个 socketChannel " + socketChannel.hashCode());
                    //将  SocketChannel 设置为非阻塞
                    socketChannel.configureBlocking(false);
                    //将socketChannel 注册到selector, 关注事件为 OP_READ， 同时给socketChannel
                    //关联一个Buffer
                    socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
                }
                if(key.isReadable()) {  //发生 OP_READ
                    //通过key 反向获取到对应channel
                    SocketChannel channel = (SocketChannel)key.channel();
                    //获取到该channel关联的buffer
                    ByteBuffer buffer = (ByteBuffer)key.attachment();
                    channel.read(buffer);
                    System.out.println("form 客户端 " + new String(buffer.array()));
                }
                //手动从集合中移动当前的selectionKey, 防止重复操作
                keyIterator.remove();
            }
        }
    }
}

NIO Client：

public class NIOClient {
    public static void main(String[] args) throws Exception{

        //得到一个网络通道
        SocketChannel socketChannel = SocketChannel.open();
        //设置非阻塞
        socketChannel.configureBlocking(false);
        //提供服务器端的ip和端口
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 6666);
        //连接服务器
        if (!socketChannel.connect(inetSocketAddress)) {

            while (!socketChannel.finishConnect()) {
                System.out.println("因为连接需要时间，客户端不会阻塞，可以做其它工作..");
            }
        }
        //...如果连接成功，就发送数据
        String str = "hello, UESTC~";
        //Wraps a byte array into a buffer
        ByteBuffer buffer = ByteBuffer.wrap(str.getBytes());
        //发送数据，将 buffer 数据写入 channel
        socketChannel.write(buffer);
        System.in.read();
    }
}

3 主从Reactor多线程

单Reactor 多线程模型中，Reactor在单线程中运行，高并发场景下容易成为性能瓶颈，可以让Reactor在多线程中运行：

• Reactor主线程MainReactor对象通过select 监听连接事件, 收到事件后，通过Acceptor处理连接事件
• 当 Acceptor 处理连接事件后，MainReactor 将连接分配给SubReactor
• Subreactor 将连接加入到连接队列进行监听,并创建handler进行各种事件处理
• 当有新事件发生时，Subreactor 就会调用对应的handler处理
• Handler 通read读取数据，分发给后面的worker线程处理
• worker线程池分配独立的worker 线程进行业务处理，并返回结果
• handler 收到响应的结果后，再通过send 将结果返回给 Client
• Reactor主线程可以对应多个 Reactor 子线程, 即 MainRecator 可以关联多个 SubReactor