NIO服务端创建过程

NIO服务端创建过程

//步骤1： 打开ServerSocketChannel， 用于监听客户端的连接，它是所有客户端连接的父管道，代码示例如下。 
ServerSocketChannel acceptSvr = ServerSocketChannel.open();

//步骤2：绑定监听端口，设置连接为非阻塞模式，示例代码如下：
acceptSvr.socket().bind(new InetSocketAddress(InetAddress.getByName("IP"), port));
acceptSvr.configureBlocking(false);

//步骤3：创建Reactor线程，创建多路复用器并启动线程，代码如下：
 Selector selector = Selector.open();
 new Thread(new ReactorTask()).start();

//步骤4：将ServerSocketChannel注册到Reactor线程的多路复用器Selector上，监听ACCEPT事件,代码如下
 SelectionKey key = acceptSvr.register(selector, SelectionKey.OP_ACCEPT, ioHandler);

//步骤5: 多路复用器在线程run方法的无限循环体内轮询准备就绪的Key,代码如下
int num = selector.select();
Set<SelectionKey> selectedKeys = selector.selectedKeys();
Iterator<SelectionKey> it = selectedKeys.iterator();
while (it.hasNext()){
    SelectionKey key = it.next();
    //... deal with I/O event ..
}

//步骤6: 多路复用器监听到有新的客户端接入,处理新的接入请求,完成TCP三次握手,建立物理链路,代码示例如下:
SocketChannel channel = svrChannel.accept();


//步骤7: 设置客户端链路的TCP参数,示例代码如下:
channel.configureBlocking(false);
channel.socket().setReuseAddress(true);

//步骤8: 将新接入的客户端连接注册到Reactor线程的多路复用器上,监听读操作,用来读取客户端发送的网络消息,代码如下:
socketChannel.register(selector, SelectionKey.OP_READ, ioHandler);

//步骤9: 异步读取客户端请求消息到缓冲区，示例代码如下：
int readNumber = channel.read(receivedBuffer);

//步骤10：对ByteBuffer进行编解码，如果有半包消息指针Reset，继续读取后续的报文，将解码成功的消息封装成Task，投递到业务线程池中，进行业务逻辑编排，示例代码如下：

Object message = null;
while(buffer.hasRemain()){
    byteBuffer.mark();
    Object message = decode(byteBuffer);
    if(message == null){
        byteBuffer.reset();
        break;
    }
    messageList.add(message);
}
if(!byteBuffer.hasRemain())
    byteBuffer.clear();
else
    byteBuffer.compact();
if(messageList != null & !messageList.isEmpty()){
    for(Object messageE :messageList)
        handlerTask(messageE);
}

//步骤11：将POJO对象encode成ByteBuffer，调用SocketChannel的异步write接口，将消息异步发送给客户端，示例代码如下：
socketChannel.write(buffer);

**注意：**如果发送区TCP缓冲区满，会导致写半包，此时，需要注册监听写操作位，循环写，直到整包消息写入TCP缓冲区。

​ NIO 有一个主要的类Selector，这个类似一个观察者，只要我们把需要探知的socketchannel告诉Selector，我们接着做别的事情，当有事件发生时，他会通知我们，传回一组SelectionKey，我们读取这些Key，就会获得我们刚刚注册过的socketchannel，然后，我们从这个Channel中读取数据，接着我们可以处理这些数据。

public class MultiplexerTimerServer implements Runnable{
    private Selector selector;
    private ServerSocketChannel servChannel;
    private volatile boolean stop;

    public MultiplexerTimerServer(int port){
        try {
            selector = Selector.open();
            servChannel = ServerSocketChannel.open();
            servChannel.configureBlocking(false);
            servChannel.socket().bind(new InetSocketAddress(port), 1024);//端口、块大小
            servChannel.register(selector, SelectionKey.OP_ACCEPT);
            System.out.println("TimeServer is start, port:" + port);
        }catch (IOException e){
            e.printStackTrace();
        }
    }

    public void run() {
        while (!stop){
            try {
                selector.select(1000);
                Set<SelectionKey> keys = selector.selectedKeys();
                Iterator<SelectionKey> ketIt = keys.iterator();
                SelectionKey key = null;
                while (ketIt.hasNext()){
                    key = ketIt.next();
                    ketIt.remove();
                    handler(key);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

    private void handler(SelectionKey key){
        //根据key去除channel做对应的处理
    }
}

NIO Reactor模式

​ 反应器模式做法是：汽车是乘客访问的主体（Reactor），乘客上车后，到售票员（acceptor）处登记，之后乘客便可以休息睡觉去了，当到达乘客所要到达的目的地后，售票员将其唤醒即可。

/**
 * 反应器模式
 * 用于解决多用户访问并发问题
 *
 * 举个例子：餐厅服务问题
 *
 * 传统线程池做法：来一个客人(请求)去一个服务员(线程)
 * 反应器模式做法：当客人点菜的时候，服务员就可以去招呼其他客人了，等客人点好了菜，直接招呼一声“服务员”
 *
 * @author linxcool
 */
public class Reactor implements Runnable {
    public final Selector selector;
    public final ServerSocketChannel serverSocketChannel;
    public Reactor(int port) throws IOException{
        selector = Selector.open();
        serverSocketChannel = ServerSocketChannel.open();
        InetSocketAddress inetSocketAddress = new InetSocketAddress(InetAddress.getLocalHost(), port);
        serverSocketChannel.socket().bind(inetSocketAddress);
        serverSocketChannel.configureBlocking(false);

        //向selector注册该channel
        SelectionKey selectionKey = serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        //利用selectionKey的attach功能绑定Acceptor 如果有事情，触发Acceptor
        selectionKey.attach(new Acceptor(this));
    }
    public void run() {
        try {
            while (!Thread.interrupted()){
                selector.select();
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> it = selectionKeys.iterator();
                //Selector如果发现channel有OP_ACCEPT或READ事件发生，下列遍历就会进行。
                while (it.hasNext()){
                    //来一个事件 第一次触发一个accepter线程
                    //以后触发SocketReadHandler
                    SelectionKey selectionKey = it.next();
                    dispatch(selectionKey);
                    selectionKeys.clear();

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

    /**
     * 运行Acceptor或SocketReadHandler
     * @param key
     */
    private void dispatch(SelectionKey key) {
        Runnable r = (Runnable)(key.attachment());
        if (r != null){
            r.run();
        }
    }
}


public class Acceptor implements Runnable {
    private Reactor reactor;

    public Acceptor(Reactor reactor) {
        this.reactor = reactor;
    }



    public void run() {
        try {
            SocketChannel socketChannel = reactor.serverSocketChannel.accept();
            if(socketChannel != null)//调用Handler来处理channel
                new SocketReadHandler(reactor.selector, socketChannel);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}


public class SocketReadHandler implements Runnable {
    private SocketChannel socketChannel;

    public SocketReadHandler(Selector selector, SocketChannel socketChannel)
        throws IOException {
        this.socketChannel = socketChannel;
        socketChannel.configureBlocking(false);
        SelectionKey selectionKey = socketChannel.register(selector, 0);

        //将SelectionKey绑定为本Handler 下一步有事件触发时，将调用本类的run方法。
        //参看dispatch(SelectionKey key)
        selectionKey.attach(this);

        //同时将SelectionKey标记为可读，以便读取。
        selectionKey.interestOps(SelectionKey.OP_READ);
        selector.wakeup();
    }

    /**
     * 处理读取数据
     */
    public void run() {
        ByteBuffer inputBuffer=ByteBuffer.allocate(1024);
        inputBuffer.clear();
        try {
            socketChannel.read(inputBuffer);
            //激活线程池 处理这些request
            //requestHandle(new Request(socket,btt));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

NIO客户端创建过程

//步骤1：打开SocketChannel，绑定客户端端口（可选，默认系统会随机分配一个可用的端口），示例代码如下：
SocketChannel clientChannel = SocketChannel.open();

//步骤2：设置SocketChannel为非阻塞模式，同时设置客户端连接的TCP参数，示例代码如下：
clientChannel.configureBlocking(false);
socket.setReuseAddress(true);
socket.setReceiveBufferSize(BUFFER_SIZE);
socket.setSendBufferSize(BUFFER_SIZE);

//步骤3：异步连接服务端，示例代码如下：
boolean connected = clientChannel.connect(new InetSocketAddress("IP", port));

//步骤4：判断是否连接成功，如果连接成功，则直接注册读状态位到多路复用器中，如果当前没有连接成功（异步连接，返回false，说明客户端已经发送sync包，服务端没有返回ack包，物理链路还没有建立），示例代码如下：
if (connected)  {
    clientChannel.register( selector, SelectionKey.OP_READ, ioHandler);
} else {
    clientChannel.register( selector, SelectionKey.OP_CONNECT, ioHandler);
}

//步骤5：向Reactor线程的多路复用器注册OP_CONNECT状态位，监听服务端的TCP ACK应答，示例代码如下：
 clientChannel.register( selector, SelectionKey.OP_CONNECT, ioHandler);

//步骤6：创建Reactor线程，创建多路复用器并启动线程，代码如下：
Selector selector = Selector.open();
New Thread(new ReactorTask()).start();

//步骤7：多路复用器在线程run方法的无限循环体内轮询准备就绪的Key，代码如下：
int num = selector.select();
Set selectedKeys = selector.selectedKeys();
Iterator it = selectedKeys.iterator();
while (it.hasNext()) {
    SelectedKey key = (SelectedKey) it.next();
}
//步骤8：接收 connect事件进行处理，代码如下：
if (key.isConnectable())
  //handlerConnect(); 
    
//步骤9：判断连接结果，如果连接成功，注册读事件到多路复用器，示例代码如下：
 if (channel.finishConnect())
   registerRead();

//步骤10：注册读事件到多路复用器：
clientChannel.register( selector, SelectionKey.OP_READ, ioHandler);

//步骤11：异步读客户端请求消息到缓冲区，示例代码如下
int  readNumber =  channel.read(receivedBuffer);

//步骤12：对ByteBuffer进行编解码，如果有半包消息接收缓冲区Reset，继续读取后续的报文，将解码成功的消息封装成Task，投递到业务线程池中，进行业务逻辑编排，示例代码如下：
Object message = null;
while(buffer.hasRemain())
{
       byteBuffer.mark();
       Object message = decode(byteBuffer);
       if (message == null)
       {
          byteBuffer.reset();
          break;
       }
       messageList.add(message );
}
if (!byteBuffer.hasRemain())
byteBuffer.clear();
else
    byteBuffer.compact();
if (messageList != null & !messageList.isEmpty())
{
for(Object messageE : messageList)
   handlerTask(messageE);
}

//步骤13：将POJO对象encode成ByteBuffer，调用SocketChannel的异步write接口，将消息异步发送给客户端，示例代码如下：
socketChannel.write(buffer);  

参考资料 ： https://www.cnblogs.com/nullzx/p/8932977.html

《Netty5.0 架构剖析和源码解读》 李林锋

Netty 服务端创建

ServerBootstrap 服务端启动辅助类

内核需要维护两个队列，未连接队列和已连接队列，根据TCP三次握手过程中三个分节来分割两个队列。

服务器处于listen状态时收到客户端syn分节（connect）syn响应及时对客户端syn的ack，此条目在第三个分节到达前(客户端对服务器syn的ack)一直保留在未完成队列中，如果三次握手完成，该条目将从未完成连接队列搬到已完成连接队列尾部。