NIO服务端创建过程

最新推荐文章于 2022-07-26 16:48:30 发布
最新推荐文章于 2022-07-26 16:48:30 发布
阅读量279 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/e31006/article/details/103913239
版权

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)一直保留在未完成队列中，如果三次握手完成，该条目将从未完成连接队列搬到已完成连接队列尾部。

卢克飞
关注
专栏目录
利用nio编写一个服务端和客户端用来模拟非阻塞模式
weixin_59244784的博客
05-09 121
利用nio编写一个服务端和客户端用来模拟非阻塞模式
NIO的工作流程
wittdong的博客
08-05 1253
一、传统IO（BIO）和NIO BIO是同步阻塞的，即一个请求分配一个线程，就是再客户端发送请求到服务器的时候，服务器会为这个客户端分配一个线程去处理相关的读写操作，且在此期间，该线程是阻塞的，不能接收其他客户端的请求。这样的阻塞如果是单线程的话，在多用户的情况下会造成非常不好的系统体验，且会造成cpu的浪费，所以需要用多线程来处理这样的请求。但是使用多线程也有缺点：线程创建和销毁的成本较高；线程还会占有一定的内存，如果线程的数量较多，数千的时候，会造成吃掉一半的jvm内存；另外线程切换的成...
java_Selector示例
悲剧的程序猿
01-17 648
呵呵，我来告诉你吧，至于例子代码在我的回答记录中有。你自己翻来去看，是用nio给一个学生写的BBS聊天室。 在用nio通讯的过程我用以下情景给你模拟： 1. 学校(ServerSocketChannel) 2。 学校教务处（Selector） 3。 老师 (ServerSocket ) 4。 学生 (SocketChannel) 5。 员工号/学生号（SelectionKe
利用NIO建立Socket服务器
孔令宽的专栏
11-19 695
利用NIO建立Socket服务器 2011-12-07 17:05 tonlion2046 tonlion2046的博客 我要评论(0) 字号：T | T Socket的Channel在Selector上注册某一种动作，Selector通过select操作，监视所有在该Selector注册过的Channel的对应的动作，如果监测到某一对应的动作，则返回selectedKeys，自己手动取到...
NIO的过程
qq_43234235的博客
07-14 254
同步与异步 同步： 同步就是发起一个调用后，被调用者未处理完请求之前，调用不返回。 异步： 异步就是发起一个调用后，立刻得到被调用者的回应表示已接收到请求，但是被调用者并没有返回结果，此时我们可以处理其他的请求，被调用者通常依靠事件，回调等机制来通知调用者其返回结果。 NIO： NIO主要有三大核心部分：Channel(通道)，Buffer(缓冲区), Selector。传统IO基于字节流和字符流进行操作，而NIO基于Channel和Buffer(缓冲区)进行操作，数据总是从通道读取到缓冲区中，或者从
服务器nio协议,java Nio使用NioSocket客户端与服务端交互实现方式
weixin_35900054的博客
08-11 1061
NioSocket 客户端与服务端交互实现java Nio是jdk1.4新增的io方式—–nio(new IO)，这种方式在目前来说算不算new，更合适的解释应该是non-block IO。non-block是相对于传统的io方式来讲的。传统的Io方式是阻塞的，我们拿网络io来举例，传统的io模型如下：服务端主线程负责不断地server.accept()，如果没有客户端请求主线程就会阻塞，当客户端...
Mina 2.0入门与解析：高性能NIO服务端框架指南
5. **后记**：总结整个学习过程，回顾Mina作为NIO框架、客户端/服务端架构、网络套接字库和事件驱动异步API的特点，强调其作为通讯框架的核心价值。 通过阅读这份笔记，读者不仅能学习到Mina 2.0的具体使用方法，还...
Netty服务端创建
sunshine052697的专栏
02-28 1368
1、Netty服务端创建时序图 分步详细说明： 1）创建ServerBootstrap实例。ServerBootstrap是Netty服务端的启动辅助类，她提供了一系列的方法用于设置服务端启动相关的参数。 2）设置并绑定Reactor线程池。Netty的Reactor线程池是 EventLoopGroup，它实际上是EventLoop的数组。Eventloop的职责是处理所有注册到本线程...
使用Netty搭建服务端和客户端过程详解
08-25
使用Netty搭建服务端和客户端过程详解 Netty是当前Java领域中最流行的网络编程框架之一，它提供了一个简洁、灵活、可扩展的架构，可以轻松地构建高性能的网络应用程序。在本篇文章中，我们将详细介绍使用Netty搭建...
NIO服务端主要创建过程
weixin_30702887的博客
07-14 65
NIO服务端主要创建过程： 步骤一：打开ServerSocketChannel，用于监听客户端的连接，它是所有客户端连接的副管道，示例代码如下： ServerSocketChannel acceptorSvr = ServerSocketChannel.open(); 步骤二：绑定监听端口，设置连接为非阻塞模式，示例代码如下： acceptTo...
nio通讯过程
chris_hhao的博客
08-10 277
初步了解nio，但是一直很难理解。网上看到一篇博文，感觉讲的非常好。 nio通讯过程情景模拟 &gt;1.学校（ServerSocketChannel） &gt;2.学校教务处（Selector） &gt;3.老师（ServerSocket） &gt;4.学生（SocketChannel） &gt;5.员工号/学生号（SelectionKey） 学校相当于我们的网络应用程序，一旦开学...
NIO开发流程
JinXYan的博客
08-04 693
NIO原理剖析 Java原生NIO开发大致流程: 第一步，绑定一个服务的端口 这与传统阻塞IO中的ServerSocket类似，没什么好说的 第二步，打开通道管理器Selector并在Selector上注册一个事件 当注册的事件发生时，Selector.select()会返回，否则一直阻塞。这一步很有意思，也是NIO第一个与传统IO不同的地方，NIO通过一个...
NIO大概流程
weixin_40003295的博客
08-09 1008
1、多个Client同时注册到多路复用器selector上； 2、selector遍历所有注册的通道； 3、查看通道状态（包括Connect、Accept、Read、Write）； 4、根据状态执行相应状态的操作；...
IO系列学习总结三：三张图带你了解NIO通信程序的执行流程
avengerEug的博客
02-27 619
前言 上篇文档：IO系列学习总结二：认识NIO，从ByteBuffer开始，我们了解了NIO解决了BIO阻塞的问题来达到高并发的目的。其中，还用了三张图了解了NIO中的ByteBuffer及常用API。上文总结到NIO的几个核心组件：Selector、SeletedKey、ByteBuffer、ServerSockerChannel、SocketChannel，我们详细了解了ByteBuffer组件的底层原理。今天，我们以三张图类来认识NIO程序通信的流程。废话不多说，咱们直接进行今天旅程。 一、三张图
NIO流程思考---理解流程
qq_20146211的博客
01-17 527
NIO是极其重要的东西，值得去深入理解
NIO总结文——一篇读懂NIO整个流程
qq_44587855的博客
07-26 755
服务器的工作 selector的准备工作 1.1 这里以windows平台为例会初始化一个WindowsSelectorImpl ServerSocketChannel的准备工作 2.1 向selector注册该ServerSocketChannel 3.1 会执行 Selector.register方法，首先在WindowsSelectorImpl的父类SelectorImpl创建一个SelectionsKeyImpl对象，参与到之后的整个注册过程 3.2 继续执行WindowsSelecto
Java从BIO到NIO的演进过程
womeiyouzaihuashui的博客
01-14 2587
前言 关于Java的IO这一块，说实话一直是让人又爱又恨的存在。大部分程序员实际工作中很少会接触文件操作相关的，即使用到了，百度随便找个工具类，能解决问题就完事。 然而你真正打算去学习IO流的时候，网上的文章上来就是一张这种图片，虽说总结得很好，但直接让人失去了看下去的欲望。 那么 ...
kafka源码解析（6）kafka网络设计如何用nio建立连接发送数据
ligen1112的博客
09-26 270
kafka网络设计发送流程，较为复杂，画了一个全局图后才算明了，下面解读下 sendProducerData流程 send的发送数据方法sendProducerData中，首先会调用recordAccumulator的ready（红色）方法检查哪个消息分区可以发送数据得到ReadyCheckResult（包含可以发送的tp对应的node），顺便看下有没有没见过的新topicPartition,有后面就去更新元数据，然后调用networkClient的ready方法，这就是要检查node的连接状态了，没联通
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值