NIO消息边界问题处理

最新推荐文章于 2023-07-21 04:01:16 发布
最新推荐文章于 2023-07-21 04:01:16 发布
阅读量1.4w 收藏
点赞数
分类专栏： Java开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GoSaint/article/details/118096279
版权
本文介绍了TCP/IP通信中如何处理消息边界问题，包括使用固定长度、分隔符和TLV格式等策略，以及面对不同情况如缓冲区大小与消息大小不匹配时的解决方案。同时，文章还探讨了服务器端处理可读事件的机制，展示了读取和写入操作的示例代码，强调了ByteBuffer的合理分配和管理对于高并发连接的重要性。
摘要由CSDN通过智能技术生成

文章目录

问题描述

@Slf4j
public class EchoServer4 {

    public static void main(String[] args) throws IOException {
        // 创建selector，可以管理多线程
        Selector selector = Selector.open();
        ServerSocketChannel ssc= ServerSocketChannel.open();
        ssc.bind(new InetSocketAddress(8080));
        //设置为非阻塞
        ssc.configureBlocking(false);
        //注册ServerSocketChannel到selector里面
        SelectionKey sscKey = ssc.register(selector, 0, null);
        log.debug("sscKey:{}",sscKey);
        //关注accept事件
        sscKey.interestOps(SelectionKey.OP_ACCEPT);
        while (true){
            //如果没有连接，那么会阻塞在这里
            selector.select();
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()){
                SelectionKey key = iterator.next();
                //删除key
                iterator.remove();
                log.debug("key:{}",key);
                //连接事件
                if (key.isAcceptable()) {
                    //获取对应的channel
                    ServerSocketChannel channel = (ServerSocketChannel)key.channel();
                    SocketChannel sc = channel.accept();
                    sc.configureBlocking(false);
                    //注册SocketChannel
                    SelectionKey scKey = sc.register(selector, 0, null);
                    //关注读取事件
                    scKey.interestOps(SelectionKey.OP_READ);
                    log.debug("{}",sc);
                    //读取事件
                }else if(key.isReadable()){
                    //ctrl+alt+t   try-catch快键
                    try {
                        SocketChannel channel =(SocketChannel) key.channel();
                        ByteBuffer buffer = ByteBuffer.allocate(4);
                        int read = channel.read(buffer);
                        if(read==-1){
                            key.cancel();
                        }else {
                            buffer.flip();
                            System.out.println(Charset.defaultCharset().decode(buffer));
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                        key.cancel();
                    }
                }

            }
        }
    }
}

ByteBuffer buffer = ByteBuffer.allocate(4);这里buffer容量设置小。第一次客户端发送“hi!”,正常打印，第二次发送“中国”，出现乱码和换行。
在这里插入图片描述

原因分析：一个buffer4个字节。中文UTF-8编码，每个汉字3个字节，总共6个字节。索引多次读取的时候，第一次读取中+国的三分之一。第二次完整读取国的剩余部分。所以国没有读取完整，出现了乱码。

提示：以下是本篇文章正文内容，下面案例可供参考

一、处理消息边界

示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。

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

解决思路：

  1. 一种思路是固定消息长度，数据包大小一样，服务器按预定长度读取，缺点是浪费带宽

比如客户端和服务端约定，客户端每次发送1024字节。服务端每次接受1024字节。客户端超出的下一次发送，并且补齐不足的部分，使满足1024.
在这里插入图片描述

  1. 另一种思路是按分隔符拆分，缺点是效率低
    比如每次遇到\n，代表一条消息。
  2. TLV 格式，即 Type 类型、Length 长度、Value 数据，类型和长度已知的情况下，就可以方便获取消息大小，分配合适的 buffer，缺点是 buffer 需要提前分配，如果内容过大，则影响 server 吞吐量
  • Http 1.1 是 TLV 格式
  • Http 2.0 是 LTV 格式
客户端1 服务器 ByteBuffer1 ByteBuffer2 发送 01234567890abcdef3333\r 第一次 read 存入 01234567890abcdef 扩容 拷贝 01234567890abcdef 第二次 read 存入 3333\r 01234567890abcdef3333\r 客户端1 服务器 ByteBuffer1 ByteBuffer2

使用分隔符解决

@Slf4j
public class EchoServer4 {

    public static void main(String[] args) throws IOException {
        // 创建selector，可以管理多线程
        Selector selector = Selector.open();
        ServerSocketChannel ssc= ServerSocketChannel.open();
        ssc.bind(new InetSocketAddress(8080));
        //设置为非阻塞
        ssc.configureBlocking(false);
        //注册ServerSocketChannel到selector里面
        SelectionKey sscKey = ssc.register(selector, 0, null);
        log.debug("sscKey:{}",sscKey);
        //关注accept事件
        sscKey.interestOps(SelectionKey.OP_ACCEPT);
        while (true){
            //如果没有连接，那么会阻塞在这里
            selector.select();
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()){
                SelectionKey key = iterator.next();
                //删除key
                iterator.remove();
                log.debug("key:{}",key);
                //连接事件
                if (key.isAcceptable()) {
                    //获取对应的channel
                    ServerSocketChannel channel = (ServerSocketChannel)key.channel();
                    SocketChannel sc = channel.accept();
                    sc.configureBlocking(false);
                    //注册SocketChannel
                    SelectionKey scKey = sc.register(selector, 0, null);
                    //关注读取事件
                    scKey.interestOps(SelectionKey.OP_READ);
                    log.debug("{}",sc);
                    //读取事件
                }else if(key.isReadable()){
                    //ctrl+alt+t   try-catch快键
                    try {
                        SocketChannel channel =(SocketChannel) key.channel();
                        ByteBuffer buffer = ByteBuffer.allocate(16);
                        int read = channel.read(buffer);
                        if(read==-1){
                            key.cancel();
                        }else {
                           split(buffer);
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                        key.cancel();
                    }
                }

            }
        }
    }

    private static void split(final ByteBuffer buffer) {
        buffer.flip();
        for(int i=0;i<buffer.limit();i++){
            if (buffer.get(i)=='\n') {
                //遇到\n，表示一个完整的语句。写入的buffer
                int length=i+1-buffer.position();
                ByteBuffer target = ByteBuffer.allocate(length);
                //将数据写入target
                for (int j = 0; j < target.limit(); j++) {
                    // 将buffer中的数据写入target中
                    target.put(buffer.get());
                }
                debugAll(target);
            }
        }
        //读取完毕之后读取剩余的部分，不能使用clear。clear会从头开始的
        buffer.compact();
    }

}

1、处理消息边界-容量超出

但是客户端长度大于buffer的长度之后，就会产生多次读取，最终只会读取到最后一次的数据。

在这里插入图片描述

2、处理消息边界-附件与扩容

@Slf4j
public class EchoServer5 {

    public static void main(String[] args) throws IOException {
        // 创建selector，可以管理多线程
        Selector selector = Selector.open();
        ServerSocketChannel ssc= ServerSocketChannel.open();
        ssc.bind(new InetSocketAddress(8080));
        //设置为非阻塞
        ssc.configureBlocking(false);
        //注册ServerSocketChannel到selector里面
        SelectionKey sscKey = ssc.register(selector, 0, null);
        log.debug("sscKey:{}",sscKey);
        //关注accept事件
        sscKey.interestOps(SelectionKey.OP_ACCEPT);
        while (true){
            //如果没有连接，那么会阻塞在这里
            selector.select();
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()){
                SelectionKey key = iterator.next();
                //删除key
                iterator.remove();
                log.debug("key:{}",key);
                //连接事件
                if (key.isAcceptable()) {
                    //获取对应的channel
                    ServerSocketChannel channel = (ServerSocketChannel)key.channel();
                    SocketChannel sc = channel.accept();
                    sc.configureBlocking(false);
                    ByteBuffer buffer = ByteBuffer.allocate(16);
                    //注册SocketChannel。将buffer和channel对应
                    SelectionKey scKey = sc.register(selector, 0, buffer);
                    //关注读取事件
                    scKey.interestOps(SelectionKey.OP_READ);
                    log.debug("{}",sc);
                    //读取事件
                }else if(key.isReadable()){
                    //ctrl+alt+t   try-catch快键
                    try {
                        SocketChannel channel =(SocketChannel) key.channel();
                        //获取关联的附件
                        ByteBuffer buffer =(ByteBuffer) key.attachment();
                        int read = channel.read(buffer);
                        if(read==-1){
                            key.cancel();
                        }else {
                           split(buffer);
                           if(buffer.position()==buffer.limit()){
                               ByteBuffer newBuffer = ByteBuffer.allocate(buffer.capacity() * 2);
                               buffer.flip();
                               newBuffer.put(buffer);
                               key.attach(newBuffer);
                           }
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                        key.cancel();
                    }
                }

            }
        }
    }

    private static void split(final ByteBuffer buffer) {
        buffer.flip();
        for(int i=0;i<buffer.limit();i++){
            if (buffer.get(i)=='\n') {
                //遇到\n，表示一个完整的语句。写入的buffer
                int length=i+1-buffer.position();
                ByteBuffer target = ByteBuffer.allocate(length);
                //将数据写入target
                for (int j = 0; j < target.limit(); j++) {
                    // 将buffer中的数据写入target中
                    target.put(buffer.get());
                }
                debugAll(target);
            }
        }
        //读取完毕之后读取剩余的部分，不能使用clear。clear会从头开始的
        buffer.compact();
    }

}

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

3、处理消息边界-bytebuffer大小分配

ByteBuffer 大小分配
  • 每个 channel 都需要记录可能被切分的消息，因为 ByteBuffer 不能被多个 channel 共同使用，因此需要为每个 channel 维护一个独立的 ByteBuffer
  • ByteBuffer 不能太大，比如一个 ByteBuffer 1Mb 的话，要支持百万连接就要 1Tb 内存，因此需要设计大小可变的 ByteBuffer
    • 一种思路是首先分配一个较小的 buffer，例如 4k，如果发现数据不够，再分配 8k 的 buffer，将 4k buffer 内容拷贝至 8k buffer，优点是消息连续容易处理，缺点是数据拷贝耗费性能，参考实现 http://tutorials.jenkov.com/java-performance/resizable-array.html
    • 另一种思路是用多个数组组成 buffer，一个数组不够，把多出来的内容写入新的数组，与前面的区别是消息存储不连续解析复杂，优点是避免了拷贝引起的性能损耗

二、处理可写事件

server端

public class WriteServer {

    public static void main(String[] args) throws IOException {
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.configureBlocking(false);

        Selector selector = Selector.open();
        ssc.register(selector, SelectionKey.OP_ACCEPT);

        ssc.bind(new InetSocketAddress(8080));

        while (true){
            selector.select();
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey sscKey = iterator.next();
                iterator.remove();
                if (sscKey.isAcceptable()) {
                    SocketChannel sc = ssc.accept();
                    sc.configureBlocking(false);
                    SelectionKey scKey = sc.register(selector, 0, null);
                    scKey.interestOps(SelectionKey.OP_READ);
                    StringBuilder sb=new StringBuilder();
                    for(int i=0;i<300000000;i++){
                        sb.append("a");
                    }
                    ByteBuffer buffer = Charset.defaultCharset().encode(sb.toString());
                    int write = sc.write(buffer);
                    System.out.println(write);
                    if (buffer.hasRemaining()){
                        scKey.interestOps(scKey.interestOps()+SelectionKey.OP_WRITE);
                        scKey.attach(buffer);
                    }
                }else if(sscKey.isWritable()){
                    ByteBuffer buffer = (ByteBuffer) sscKey.attachment();
                    SocketChannel sc = (SocketChannel) sscKey.channel();
                    int write = sc.write(buffer);
                    System.out.println("实际写入字节:" + write);
                    if (!buffer.hasRemaining()) { // 写完了
                        sscKey.interestOps(sscKey.interestOps() - SelectionKey.OP_WRITE);
                        sscKey.attach(null);
                    }
                }
            }
        }
    }
}

客户端

public class WriteClient {

    public static void main(String[] args) throws IOException {
        SocketChannel open = SocketChannel.open();
        open.connect(new InetSocketAddress("localhost",8080));
        int read=0;
        while (true){
            ByteBuffer buffer = ByteBuffer.allocate(1024 * 1024);
            read += open.read(buffer);
            System.out.println(read);
            buffer.clear();
        }
    }
}
大佛拈花
关注
专栏目录
消息边界处理
cristianoxm的博客
09-22 380
一、消息边界问题 接收如下： 可以看到，由于系统默认编码是utf-8，每个中文会被编码为3个字节，然后我们由于这一行： ByteBuffer buffer = ByteBuffer.allocate(4); 导致一次只能读取4个字节，那么就会触发两次读取，第一次读到中和1/3国，第二次读到2/3国。最终造成国乱码。 根源就是消息边界问题。 二、消息边界情况 三、解决方法 一种思路是固定消息长度，数据包大小一样，服务器按预定长度读取，缺点是浪费带宽 另一种思路是按分隔符拆分，缺点是效率低 TLV
【Java TCP/IP Soket】— 消息边界的问题解决
开挂的程序猿
12-09 3310
【Java TCP/IP Soket】— 关于消息边界问题，在TCP套接字处理接收消息中尤为重要，所以大家一定要学会解决它！
32、Nio（selector（处理消息边界问题（三种方案）））
分享java学习路上的一些笔记，不足之处多多见谅。
11-12 415
1、若是传的数据大于buffer，我们可以将buffer扩容处理第一种方案：传的数据小于buffer，固定消息的长度，我们再给服务器也固定长度读取（容易影响带宽）第二种方案：我们根据分隔符拆分消息，我们创建临时buffer大小，去接收消息（有两个问题1、我们要去遍历消息找到分隔符，时间开销大2、若是其消息长度还是大于buffer长度，还是要考虑第三种方案：我们传消息的时候先传我们消息的大小给我们的服务器。第一种方案：传的数据小于buffer，第二种方案：我们根据分隔符拆分消息。若是传的数据大于buffer，
Netty——网络编程 NIO（Selector处理read事件 消息边界问题）代码示例
小志的博客
09-04 294
Netty——网络编程 NIO（Selector处理read事件 消息边界问题）代码示例
nio-selector-处理消息边界(三大解决方案，含详细代码案例及步骤分析)
最新发布
weixin_73077810的博客
07-21 318
nio-selector-处理消息边界(三大解决方案，含详细代码案例及步骤分析).方案一：固定消息长度，数据包大小一样，服务器按预定长度读取;方案二：按分隔符动态调整缓冲数组的长度，截取合适区间;方案三：TLV格式将消息划分为类型、长度和值三个部分，以便于处理消息边界和解析
nio学习demo 处理因缓冲区满导致写入失败问题
11-11
由于TCP是流式传输，不保留消息边界，所以多个小数据包可能会被合并成一个大数据包发送，接收端如果没有正确处理，就可能出现“沾包”现象。解决这个问题的关键在于设计一种机制，使接收端能够识别出数据包的边界。 ...
java nio ppt
01-23
NIO的引入主要是为了解决传统IO（即BIO）中高并发时的性能问题，因为NIO采用的是基于缓冲区和基于通道（Channel）的方式进行操作，可以通过选择器（Selectors）实现对多个通道（Channel）的管理。 NIO和传统的IO...
动态演示nio中的buffer相关操作.zip
09-09
Java NIO（New IO）是Java 1.4版本引入的一个新特性，它提供了一种更有效、更灵活的方式来处理I/O操作。NIO的核心组件之一就是Buffer，它在I/O操作中扮演着至关重要的角色。这个压缩包“动态演示nio中的buffer相关...
Java性能优化之使用NIO提升性能（Buffer和Channel）
01-27
Java性能优化中，NIO（New Input/Output）框架是一个重要的技术，它的引入极大地提升了Java在处理I/O操作时的效率。NIO的核心组件包括Buffer（缓冲区）和Channel（通道），它们共同解决了传统I/O模型中的一些性能...
新输入输出NIO
02-21
NIO库的设计目标是允许Java程序员实现高速I/O而无需编写本机代码，通过将耗时的I/O操作委托给操作系统，显著提升了处理速度。 在NIO中，有两个核心概念：**通道（Channels）**和**缓冲区（Buffers）**。通道是连接...
（nio）Selector-处理消息边界-附件与扩容
QRLYLETITBE的博客
01-15 614
（nio）Selector-处理消息边界-附件与扩容
java nio 内存过大 限制_NIO非阻塞网络编程三大核心理念
weixin_39889597的博客
03-06 230
本次开始NIO网络编程，之前已经说过BIO，对于阻塞IO里面的问题一定有了清晰的认识，在JDK1.4版本后，提供了新的JAVA IO操作非阻塞API，用意替换JAVA IO 和JAVA NetWorking相关的API。NIO其实有个名称叫new IO。(一)NIO介绍java.nio全称java non-blocking IO(实际上是 new io)，是指JDK 1.4 及以上版本里提供的新a...
TCP协议的无消息边界问题
weixin_34221773的博客
12-12 780
使用TCP协议编写应用程序时，需要考虑一个问题：TCP协议是无消息边界的，即不能保证来自单个Send方法的数据能被单个Receive方法读取。 eg: 第一次发送：abcdefg 第二次发送：123456 接收方接收数据时,可能会出现以下情况： 第一次接收：abcdefg123456 也可能出现：第一次接收：abc 第二次接收：efg12 第三次接收：3456 因此...
TCP和UDP的"保护消息边界"
Ubuntu 14.04配置nfs服务
04-17 384
       在socket网络程序中，TCP和UDP分别是面向连接和非面向连接的。因此TCP的socket编程，收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。       ...
Camunda 入门开发指南 - 2.2 BPMN2.0介绍 - 事件
u010249118的博客
09-03 1425
Camunda 入门开发指南 - 2.2 BPMN2.0介绍 - 事件
java nio 消息_java nio消息半包、粘包解决方案
weixin_39673303的博客
02-16 241
问题背景NIO是面向缓冲区进行通信的，不是面向流的。我们都知道，既然是缓冲区，那它一定存在一个固定大小。这样一来通常会遇到两个问题：消息粘包：当缓冲区足够大，由于网络不稳定种种原因，可能会有多条消息从通道读入缓冲区，此时如果无法分清数据包之间的界限，就会导致粘包问题；消息不完整：若消息没有接收完，缓冲区就被填满了，会导致从缓冲区取出的消息不完整，即半包的现象。介绍这个问题之前，务必要提一下我代码整...
java nio 对消息分片_NIO基础篇(三)
weixin_30670123的博客
02-16 158
NIO里对性能提升最显著的是内存映射(memory mapping)，内存访问的速度往往比文件访问的速度快几个数量级。在内存映射之前，还需要看NIO的一些其他的特性。缓冲区分片slice()方法根据现有的缓冲区创建一个子缓冲区。也就是说，它创建一个新的缓冲区，新缓冲区与原来的缓冲区的一部分共享数据。package nio;import java.nio.ByteBuffer;public clas...
Netty笔记2-Netty学习之NIO基础
吹灭读书灯 一身都是月的博客
02-19 588
Channel与BufferJava NIO系统的核心通道(Channel)和缓冲区(Buffer)。通道表示打开到 IO 设备(例如：文件、套接字)的连接。若需要使用 NIO 系统，需要获取用于连接 IO 设备的通道以及用于容纳数据的缓冲区。然后操作缓冲区，对数据进行处理简而言之，通道负责传输，缓冲区负责存储常见的Channel有以下四种，其中FileChannel主要用于文件传输，其余三种用于网络通信Buffer有以下几种，其中使用较多的是ByteBufferByteBuffer。
8 Flowable消息事件之消息开始事件（MessageStartEvent）、消息捕捉事件（MessagecatchingEvent）、消息边界事件（MessageBoundaryEvent）
qq_36305027的博客
10-23 1073
消息事件是可以通过消息来启动或者触发的事件，下面我们还是从三个方面使用消息事件。 1 开始事件MessageStartEvent 我们编写定义messagestart.bpmn20.xml，流程定义内容如下： <?xml version="1.0" encoding="UTF-8"?> <definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/
NIO深度解析：从基础到实践
NIO的核心概念和主要目标是提供一种更高效的数据处理方式，尤其是在处理大量数据时。与传统的IO（基于流的I/O）不同，NIO是以块为单位进行数据传输，从而显著提高了性能。 1. **核心概念** - **通道（Channel）**...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值