【2023】NIO从零到一入门学习——网络编程Selector

已于 2023-07-05 19:11:49 修改
阅读量103 收藏
点赞数 1
分类专栏： NIO 文章标签： nio 学习 网络
于 2023-07-05 18:55:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52315708/article/details/131561926
版权
本文介绍了JavaNIO中的Selector如何用于实现多路复用网络通信，包括Selector的基本操作、事件类型、关注事件的方法，以及处理accept和read事件的具体步骤。文章还讨论了消息边界问题及其解决方案，如固定消息长度、分隔符拆分和TLV格式。
摘要由CSDN通过智能技术生成

使用Selector进行网络通信

在这里主要使用的是IO模型中的多路复用，想详细了解io模型可以看我上一篇

多路复用

单线程可以配合Selector完成多个Channel可读写事件的监控，这称之为多路复用

  • 多路复用仅针对网络IO、普通文件IO没法利用多路复用
    在这里插入图片描述

Selector事件

  • accept ：会在有连接请求时触发 SelectionKey.*OP_ACCEPT = 16*
  • connect ：是客户端，连接建立后触发 SelectionKey.OP_CONNECT = 8
  • read ： 可读事件 SelectionKey.*OP_READ = 1*
  • write ： 可写事件 SelectionKey.OP_WRITE = 4

1、Selector常用方法

Selector.open() ：获取Selector 选择器

  • ssc.configureBlocking(false) ：配置通道为非阻塞
  • SelectionKey sscKey = ssc.register(selector, 0, null);
    • 把ssc这个Channel注册到selector 上，并且表示关注事件为0（也可以添加要关注的事件），附件为null
    • socketChannel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE);
      • // 将套接字通过到注册到选择器，关注 read和 write事件
    • scKey.interestOps(SelectionKey.*OP_READ* | SelectionKey.*OP_WRITE*) //使用的是位运算符
      • 表示关注这两个事件，也可以使用 + 号代替，
    • scKey.attach(buffer);
      • 把buffer挂载到scKey这个事件上；

2、具体实现代码

简单获取事件

public static void main(String[] args) throws IOException {
//        1、创建selector，用于管理多个channel
        Selector selector = Selector.open();
        ByteBuffer buffer = ByteBuffer.allocate(16);
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.configureBlocking(false);

//        2、建立selector 和 channel 的联系（注册）
//         SelectionKey 就是将来用于管理时间发生后，通过它可以知道事件和哪个Channel的事件
        SelectionKey sscKey = ssc.register(selector, 0, null);
//         key 只关注accept事件
        sscKey.interestOps(SelectionKey.OP_ACCEPT);
        log.debug("register key:{}"+sscKey);

        ssc.bind(new InetSocketAddress(8080));  //连接本机端口
        while (true){
//            3、select 方法，没有事件就阻塞，如果发生事件，线程恢复运行
//            （如果不处理这个事件时，不会进行阻塞；只有处理了这个事件或者取消了这个事件才会进入阻塞）
            selector.select();

//            4、处理事件,SelectionKey 内部包含了所有发生的事件
//                    获取迭代器，进行遍历事件
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()){
                SelectionKey key = iterator.next();
                log.debug("key:{}",key);
/*                ServerSocketChannel channel = (ServerSocketChannel) key.channel();
//                处理这个事件
                SocketChannel sc = channel.accept();
                log.debug("{}",sc);*/
//                取消这个事件
                key.cancel();
            }
        }
    }

流程图
在这里插入图片描述

3、accept和read事件

监听Channel事件

可以通过下面三种方法来监听是否有事件发生，方法的返回值代表有多少Channel发生了事件

方法1，阻塞直到绑定事件发生

selector.select();

方法2.阻塞直到绑定事件发生，或是超时（时间单位为ms）

selector.select(long timeout);

方法3.不会阻塞，也就是不管有没有事件，立刻返回，自己根据返回值检查是否有事件

selector.selectNow();

🔔select 何时不阻塞

  • 事件发生时
    • 客户端发起连接请求，会触发accept事件
    • 客户端发送数据过来，客户端正常、异常关闭时，都会触发 read 事件，另外如果发送的数据大于buffer 缓冲区，会触发多次读取事件
    • channel 可写，会触发write事件
    • 在linux下nio bug发生时
  • 调用selector.wakeup()
  • 调用selector.closel()
  • selector 所在线程interrupt
  • 使用Selector读取客户端数据
    • 处理完一个事件需要把事件从SelectionKey集合中删除掉，因为SelectionKey处理完这个事件后不会删除，只会做一个处理后的标记，就会一直循环执行这个已经处理过的事件（就会报错）；需要手动的把这个事件从集合中remove()掉
    • 当客户端错误断开连接时，服务器会发生一个read事件，selector集合就会往SelectionKey集合中丢这个事件，然而因为客户端已经断开连接了，这个事件就无法处理成功，会报错，需要try catch 包住；并且需要把这个事件从selector集合中取消，避免一直往SelectionKey集合中丢；正常断开也是，执行channel.read(buffer1)会返回-1，也需要手动去取消这个事件。
    • 如果传输中文字符时，如果缓冲区大小不够，出现半包时，就会出现消息边界问题
public static void main(String[] args) throws IOException {
//        1、创建selector，用于管理多个channel
        Selector selector = Selector.open();
        ByteBuffer buffer = ByteBuffer.allocate(16);
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.configureBlocking(false);

//        2、建立selector 和 channel 的联系（注册）
//         SelectionKey 就是将来用于管理事件发生后，通过它可以知道事件和哪个Channel的事件
        SelectionKey sscKey = ssc.register(selector, 0, null);
//         key 只关注accept事件
        sscKey.interestOps(SelectionKey.OP_ACCEPT);
        log.debug("register key:{}"+sscKey);

        ssc.bind(new InetSocketAddress(8080));
        while (true){
//            3、select 方法，没有事件就阻塞，如果发生事件，线程恢复运行
//            （如果不处理这个事件时，不会进行阻塞；只有处理了这个事件或者取消了这个事件才会进入阻塞）
            selector.select();

//            4、处理事件,SelectionKey 内部包含了所有发生的事件
//                    获取迭代器，进行遍历事件
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()){
                SelectionKey key = iterator.next();
//                当拿到key之后需要把key从sekectedkeys集合中删除掉，
//                      否则下次还会继续处理这个被处理过的key，就会报错
                iterator.remove();
                log.debug("key:{}",key);
//                5、区分事件类型
                if (key.isAcceptable()) {
                    ServerSocketChannel channel = (ServerSocketChannel) key.channel();
//                处理这个事件
                    SocketChannel sc = channel.accept();
                    sc.configureBlocking(false);
                    SelectionKey scKey = sc.register(selector, 0, null);
                    scKey.interestOps(SelectionKey.OP_READ);
                    log.debug("{}",sc);
                    log.debug("key{}",scKey);
                }else if (key.isReadable()){ //如果是read
//                    读取channel中的数据
                    try {
                        SocketChannel channel = (SocketChannel) key.channel();
                        ByteBuffer buffer1 = ByteBuffer.allocate(4);
                        int read = channel.read(buffer1);  //如果客户端正常断开，read的返回值是-1；
                        if (read==-1){
                            key.cancel();   //取消这个事件,避免一直往集合中放
                        }

                        buffer1.flip();
                        System.out.println(Charset.defaultCharset().decode(buffer1)); //直接打印会出现消息边界的问题
                    } catch (IOException e) {
                        e.printStackTrace();
                        key.cancel();   //当客户端异常断开时，需要把这个key取消，（从selector集合中删除，避免一直往执行集合写入）
                    }
                }
//                取消这个事件
//                key.cancel();
            }
        }
    }
}

4、处理消息边界

消息边界出现的原因

  • ByteBufeer较小，但是消息比较大
  • ByteBufeer较大，消息比较小。会出现半包现象
  • ButeBuffer较小，但是容纳了多个消息。此时会出现黏包现象

在这里插入图片描述

处理方式

  • 一种思路是固定消息长度，数据包一样，服务器按预定长度读取，缺点是浪费宽带
  • 另一种是按分隔符拆分，缺点是效率低
  • TLV格式，即Type类型、Length长度、Value数据，类型和长度已知的情况下，就可以方便获取消息大小，分配合适的buffer，缺点是buffer需要提前分配，如果内容过大，则影响server吞吐量
    • Http1.1是TLV格式：先传出类型，再传出长度，最后传出数据
    • Http2.0是LTV格式：先传出长度，再传出类型，最后传出数据

在这里插入图片描述

如果一次传输的数据过长，第一次分隔符的长度就大于了缓冲区长度，则会出现下面的情况

在这里插入图片描述

代码举例

按固定分隔符解决消息边界

  • 因为缓冲区不能够扩容，所以需要把缓冲区作为附件放入SelectionKey中，当容量不够时，进行一次扩容，更新掉附件中的缓冲区
public class Server2 {
    public static void main(String[] args) throws IOException {
//        1、创建selector，用于管理多个channel
        Selector selector = Selector.open();
        ByteBuffer buffer = ByteBuffer.allocate(16);
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.configureBlocking(false);

//        2、建立selector 和 channel 的联系（注册）
//         SelectionKey 就是将来用于管理事件发生后，通过它可以知道事件和哪个Channel的事件
        SelectionKey sscKey = ssc.register(selector, 0, null);
//         key 只关注accept事件
        sscKey.interestOps(SelectionKey.OP_ACCEPT);
        log.debug("register key:{}"+sscKey);

        ssc.bind(new InetSocketAddress(8080));
        while (true){
//            3、select 方法，没有事件就阻塞，如果发生事件，线程恢复运行
//            （如果不处理这个事件时，不会进行阻塞；只有处理了这个事件或者取消了这个事件才会进入阻塞）
            selector.select();

//            4、处理事件,SelectionKey 内部包含了所有发生的事件
//                    获取迭代器，进行遍历事件
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()){
                SelectionKey key = iterator.next();
//                当拿到key之后需要把key从sekectedkeys集合中删除掉，
//                      否则下次还会继续处理这个被处理过的key，就会报错
                iterator.remove();
                log.debug("key:{}",key);
//                5、区分事件类型
                if (key.isAcceptable()) {
                    ServerSocketChannel channel = (ServerSocketChannel) key.channel();
//                处理这个事件
                    SocketChannel sc = channel.accept();
                    sc.configureBlocking(false);
                    ByteBuffer buffer2 = ByteBuffer.allocate(5);
//                    register(注册的selector，事件数量，附件)
                    SelectionKey scKey = sc.register(selector, 0, buffer2);   //把buffer当作attachment(附件)放入SelectionKey中
                    scKey.interestOps(SelectionKey.OP_READ);
                    log.debug("{}",sc);
                    log.debug("key{}",scKey);
                }else if (key.isReadable()){ //如果是read
//                    读取channel中的数据
                    try {
                        SocketChannel channel = (SocketChannel) key.channel();
//                        获取放入SelectionKey中关联的附件
                        ByteBuffer buffer1 = (ByteBuffer) key.attachment();
                        int read = channel.read(buffer1);  //如果客户端正常断开，read的返回值是-1；
                        if (read==-1){
                            key.cancel();   //取消这个事件,避免一直往集合中放
                        }else {
                            System.out.println(buffer1);
                            split(buffer1);
                            if (buffer1.position()==buffer1.limit()){ //如果缓冲区的position和limit相等，则代表数据长度大于缓冲区，数据未读

                                ByteBuffer newBuffer = ByteBuffer.allocate(buffer1.capacity() * 2); //则把原来的容量进行扩容
                                newBuffer.flip();
                                newBuffer.put(buffer1);  //把原来缓冲区的数据放入新缓冲区
                                key.attach(newBuffer);   //再更新SelectionKey中的附件buffer
                            }
                        }
                        buffer1.flip();
                        System.out.println(Charset.defaultCharset().decode(buffer1)); //直接打印会出现消息边界的问题
                    } catch (IOException e) {
                        e.printStackTrace();
                        key.cancel();   //当客户端异常断开时，需要把这个key取消，（从selector集合中删除，避免一直往执行集合写入）
                    }
                }
//                取消这个事件
//                key.cancel();
            }
        }
    }

    private static void split(ByteBuffer buffer) {
        buffer.flip();
        for (int i = 0; i < buffer.limit(); i++) {
//            通过\n找到一条完整消息
            if (buffer.get(i)=='\n'){
                int length = i+1-buffer.position();
//                  创建指定大小的缓冲区
                ByteBuffer target = ByteBuffer.allocate(length);
//                把完整数据写入新的ByteBuffer中
                for (int j = 0; j < length; j++) {
                    target.put(buffer.get());
                }
                target.flip();
//                String s = StandardCharsets.UTF_8.decode(target).toString();
//                System.out.println(s);
                System.out.println(buffer);
            }
        }
        buffer.compact();
    }
}
方渐鸿
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一站式学习Java网络编程 全面理解BIO:NIO:AIO1
08-08
一、网络编程三剑客 - BIO、NIO、AIO BIO（Blocking I/O）是一种同步阻塞式 I/O 模式，服务器需要为每个客户端分配一个独立的线程来处理请求，导致服务器资源浪费。 NIO（Non-Blocking I/O）是一种异步非阻塞式 I/...
Java NIO编程实例之三Selector
LogicTeamLeader的专栏
04-08 2373
Java NIO主要包含三个概念，即缓冲区（Buffer）、通道（Channel）和选择器（Selector）。前面的文章已经介绍了缓冲区和通道，本文则讲述最复杂的选择器Selector。 本文是本系列的第三篇文章，关于缓冲区Buffer可以看第一篇： https://zhuanlan.zhihu.com/p/25701512 关于通道Channel可以看第二篇： https://zhuan
Java NIO 网络编程初探
12-22
Java NIO 网络编程初探 1. Java NIO Java 1.4 版本添加了一个新的IO API，称为NIO（New IO）。NIO拥有所有IO的功能，但是操作方法却完全不一样。NIO支持面向缓冲区的、基于通道的IO操作。能够更加高效的进行IO操作。...
Java网络编程从入门到精通
02-14
本教程"Java网络编程从入门到精通"旨在帮助初学者和有经验的开发者深入理解这一领域，从基础知识到高级主题，提供了一套全面的学习资源。 在Java中，网络编程主要涉及以下核心知识点： 1. **Socket编程**：Java的...
NIO网络编程
12-22
NIO网络编程 Selector选择器 进行监听，是新连接或已经连接，读写数据 常用方法 public static Selector Open(); 得到一个选择器对象 public int select(long timeout); 监听所有注册通道，存在IO流操作，将对应...
java网络编程NIO视频教程
09-12
### Java网络编程NIO视频教程知识点汇总 #### 1. Java NIO-课程简介 - **主要内容**：简述Java NIO（New IO）的概念及其与传统IO的区别。 - **学习目标**：理解NIO的基本原理及应用场景。 #### 2. Java NIO-概述 -...
【案例60】NIO导致本地内存溢出
Z.Virgil的博客
08-27 339
集成环境出现宕机，javacore中报本地内存溢出。
Java 输入与输出之 NIO【非阻塞式IO】【NIO网络编程】探索之【二】
weixin_42369079的博客
08-27 1058
Java 标准的输入/输出流（Input/Output，简称I/O）是Java语言用于读写数据的API，它提供了一系列类和接口，用于读取和写入各种类型的数据信息。 BIO全称是Blocking IO，同步阻塞式IO，是JDK1.4之前的标准IO模型。 Java NIO（New I/O）是Java 1.4版本中引入的一套全新的IO处理机制，与之前的标准IO（BIO）相比，NIO具有更高的可扩展性和灵活性，特别是在网络编程和高并发场景下，表现得更为出色。本文探讨了NIO的网络通讯应用。
union不能被初始化由于有 non-trivial构造函数
feng__shuai的博客
08-27 793
如果类的成员是具有上述非平凡构造函数、析构函数或赋值操作符的类，则该成员也被认为是非平凡的。换句话说，如果一个类包含非平凡成员对象，那么这个类的构造函数、析构函数或赋值操作符也将是非平凡的。其实在union中的成员函数nt， 虽然是非平凡成员，但是构造函数和析构函数都有，为啥union不能直接调用相关函数生成一个默认的构造函数和析构函数呢？赋值操作符用于将一个对象的值赋给另一个对象。如果一个类从虚基类继承，那么这个类的构造函数、析构函数和赋值操作符也会变成非平凡的，因为需要处理虚基类的初始化和清理。
第一个NIO开发演示
长安初雪的博客
08-26 789
在NIO中不再选择流的通信方式, 而是选择管道的方式.每个客户端对应一个管道, 来自客户端的请求通过管道发给服务端.NIO 为服务端在网络通信中引入了 Seletor , Seletor监控客户端的状态 , 使得服务端的有限线程充分复用起来.
【SQL基础】联表查询、UNION（组合查询）题目
FQY__的博客
08-24 1120
其中，一个 SELECT 语句过滤数量为 100 的行，另一个 SELECT 语句过滤 id 以 BNBG 开头的产品，最后按产品 id 对结果进行升序排序。其中，一个 SELECT 语句过滤数量为 100 的行，另一个 SELECT 语句过滤 id 以 BNBG 开头的产品，最后按产品 id 对结果进行升序排序。【问题】编写 SQL 语句，组合 Products 表中的产品名称（prod_name）和 Customers 表中的顾客名称（cust_name）并返回，然后按产品名称对结果进行升序排序。
Netty从入门到超神-NIO 三大核心(selector,channel,buffer)(二)
xuhanyii的博客
08-29 549
上一篇文章认识了一下Java的三大IO，这一章节我们详细了解一下NIO的工作原理以及三大核心SelectorChannelBuffer并尝试来做一些小案例。//返回此缓冲区容量capacity//返回此缓冲区位置position//设置缓冲区的位置position//返回此缓冲区limit//设置此缓冲区的限制limit//在此缓冲区的位置设置标记//将此缓冲区的位置重置为以前标记的位置//把position设置为mark//清除此缓冲区, 即将各个标记恢复到初始状态。
## 已解决：亲测有效的 `java.nio.charset.CoderMalfunctionError` 编码器故障错误解决方法
A1551143530的博客
08-26 662
通过以上方法，编码器故障错误问题应该能得到有效解决。如果你有其他更好的解决方案或经验，欢迎在评论区与大家分享！
Java 入门指南：初识 Java NIO
Zachyy的博客
08-29 542
Java1.4 版本引入了 NIO（New I/O or Non-Blocking I/O）java.nio。提供了一种基于缓冲区、选择器和非阻塞 IO 模型的 IO 处理方式。相比于之前的 `BIO` 模型，NIO 可以实现更高的并发、更低的延迟以及更少的资源消耗。
Java的IO模型详解-BIO,NIO,AIO
最新发布
wendao76的专栏
08-29 879
Java IO模型，bio, nio以及不常用的aio
Java 输入与输出之 NIO【非阻塞式IO】【NIO核心原理】探索之【一】
weixin_42369079的博客
08-27 844
Java 标准的输入/输出流（Input/Output，简称I/O）是Java语言用于读写数据的API，它提供了一系列类和接口，用于读取和写入各种类型的数据信息。 BIO全称是Blocking IO，同步阻塞式IO，是JDK1.4之前的标准IO模型。 Java NIO（New I/O）是Java 1.4版本中引入的一套全新的IO处理机制，与之前的标准IO（BIO）相比，NIO具有更高的可扩展性和灵活性，特别是在网络编程和高并发场景下，表现得更为出色。本文对NIO进行了深入的探索。
Java 入门指南：Java NIO —— Channel（通道）
Zachyy的博客
08-29 805
通道（Channel）是 `NIO`（New Input/Output）模型中的一个重要概念。通道代表着与底层 I/O 设备（如文件、网络套接字等）之间的连接，用于将数据传输到缓冲区或从缓冲区传输数据。 Channel 不与数据打交道，它只负责运输数据 通道在 NIO 中起到了桥梁作用，负责将数据从缓冲区传输到通道或者从通道传输到缓冲区。它是一个双向的数据传输通道。
DS | 并查集 Disjoint Set Union
Janniam的博客
08-26 351
查找（Find）：查找某个元素所属集合的根节点，用于判断两个元素是否在同一个集合内。若 'parent[ i ] == i '，那么 'i' 为这个集合的根节点。1、为了加速查找操作，通过将路径上所有的节点直接连接到根节点，降低树的高度。rank：记录了每个集合根节点的“秩”(rank)，即树的近似高度。rank不同：rank小节点连接到rank大的节点，rank无需更新。父节点：节点 'i' 的父节点为 'parent[ i ]'2、Find（查找）：查找一个元素所属集合的根节点，递归实现。
软件测试学习笔记丨Pytest配置文件
ceshiren_com的博客
08-27 1743
pytest.ini是pytest的配置文件；可以修改pytest的默认行为；不能使用任何中文符号，包括汉字、空格、引号、冒号等。
NIO网络编程之Selector选择器详解
NIO完成网络编程需要 Selector、SelectionKey和Channel三个核心组件的配合，Selector负责监听和管理多个Channel，SelectionKey表示Selector和网络通道之间的关系，ServerSocketChannel是服务端Socket程序对应的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值