什么是TCP粘包和半包问题？如何解决？

news2024/9/27 7:23:02

什么是TCP粘包问题？如何解决？

TCP粘包和半包是数据传输中比较常见的问题。所谓的粘包问题就是指在数据传输的时候，在一条消息中读取到了另一条消息的部分数据，如下图：

半包是指接收端只收到了部分的数据，而非完整的数据的情况，如下图：

 大部分情况下我们都把粘包问题和半包问题看成同一个问题，所以下文就用粘包问题来替代粘包和半包问题

为什么会有粘包问题

粘包问题发生在TCP/IP协议中，因为TCP是面向连接的传输协议，它是以流的形式传输数据的，而流数据是没有明确开始和结尾的边界的，所以就会出现粘包问题

粘包问题演示

接下来我们用代码来演示一下粘包和半包问题，为了演示的直观性，我会设置两个角色：

  • 服务器端用来接收消息
  • 客户端用来发送一段固定的消息

服务端代码实现：

import java.io.*;
import java.net.*;

public class Server {
    private static final int BYTE_LENGTH = 20;

    public static void main(String[] args) throws IOException {
        // 创建 Socket 服务器
        ServerSocket serverSocket = new ServerSocket(8888);
        // 获取客户端连接
        Socket clientSocket = serverSocket.accept();
        // 得到客户端发送的流对象
        try (InputStream inputStream = clientSocket.getInputStream()) {
            while (true) {
                // 循环获取客户端发送的信息
                byte[] bytes = new byte[BYTE_LENGTH];
                // 读取客户端发送的信息
                int count = inputStream.read(bytes, 0, BYTE_LENGTH);
                if (count > 0) {
                    // 成功接收到有效消息并打印
                    System.out.println("接收到客户端的信息是:" + new String(bytes, 0, count));
                }
            }
        }
    }
}

客户端代码实现：

import java.io.*;
import java.net.*;
import java.nio.charset.StandardCharsets;

public class Client {
    public static void main(String[] args) throws IOException {
        String serverAddress = "127.0.0.1";
        int port = 8888;

        try (Socket socket = new Socket(serverAddress, port);
             PrintWriter out = new PrintWriter(socket.getOutputStream(), true)) {
            String message = "hello,world";
            OutputStream outputStream= socket.getOutputStream();
            for (int i = 0; i < 10; i++) {
                outputStream.write(message.getBytes());
            }
        }
    }
}

 程序执行结果：

此时我们发现出现了粘包问题，正常应该是直接输出10次hello world 才对

 解决方案

粘包问题的常见解决方案有以下三种：

  1. 固定数据大小：发送方和接收方固定发送消息的大小，当字符长度不够的时候用空字符弥补，有了固定大小就知道每条消息的边界了
  2. 自定义数据协议（定义数据边界）：在TCP协议的基础上封装上一层自定义数据协议，在自定义的数据协议中，包含数据头（存储数据的大小）和数据的具体内容，这样服务端的得到的数据头就可以知道数据的具体长度，也就没有粘包问题
  3. 以特殊字符结尾：比如以“/n”字符结尾，这样就可以直到数据的具体边界，可以避免粘包问题（推荐使用）
解决方案一：固定数据大小

收、发固定大小的数据，服务端实现代码：

import java.io.*;
import java.net.*;

public class Server {
    private static final int BYTE_LENGTH = 1024;

    public static void main(String[] args) throws IOException {
        // 创建 Socket 服务器
        ServerSocket serverSocket = new ServerSocket(8888);
        // 获取客户端连接
        Socket clientSocket = serverSocket.accept();
        // 得到客户端发送的流对象
        try (InputStream inputStream = clientSocket.getInputStream()) {
            while (true) {
                // 循环获取客户端发送的信息
                byte[] bytes = new byte[BYTE_LENGTH];
                // 读取客户端发送的信息
                int count = inputStream.read(bytes);
                if (count > 0) {
                    // 成功接收到有效消息并打印
                    System.out.println("接收到客户端的信息是:" + new String(bytes, 0, count));
                }
            }
        }
    }
}

客户端实现代码：

import java.io.*;
import java.net.*;
import java.nio.charset.StandardCharsets;

public class Client {
    private static final int BYTE_LENGTH = 1024;
    public static void main(String[] args) throws IOException, InterruptedException {
        String serverAddress = "127.0.0.1";
        int port = 8888;
        String message = "hello,world";
        try (Socket socket = new Socket(serverAddress, port)) {

            OutputStream outputStream= socket.getOutputStream();
            byte[] bytes = new byte[BYTE_LENGTH];
            int idx= 0;
            for(byte b:message.getBytes()){
                bytes[idx]= b;
                idx++;
            }
            for (int i = 0; i < 10; i++) {
                outputStream.write(bytes,0,BYTE_LENGTH);
            }
        }
    }
}

 运行结果：

后面是字符编码的问题

优缺点分析
从以上代码可以看出，虽然这种方式可以解决粘包问题，但这种固定数据大小的传输方式，当数据量比较小时会使用空字符来填充，所以会额外的增加网络传输的负担，因此不是理想的解决方案

解决方案二：自定义请求协议

这种解决方案的实现思路是将请求的数据封装成两部分：消息头（发送的数据大小）+消息体（发送的具体数据），如下图：

此解决方案的实现为以下三部分：

  1. 编写一个消息的封装类
  2. 编写客户端
  3. 编写服务器端 

消息的封装类：

import java.nio.charset.StandardCharsets;

public class CustomProtocol {
    private static final int HEAD_SIZE = 8; // 假设消息头固定为8个字节

    public static byte[] toBytes(String context) {
        // 协议体 byte 数组
        byte[] bodyByte = context.getBytes(StandardCharsets.UTF_8);
        int bodyByteLength = bodyByte.length;

        // 最终封装对象
        byte[] result = new byte[HEAD_SIZE + bodyByteLength];

        // 借助 NumberFormat 将int 转换为 byte[]
        NumberFormat numberFormat = NumberFormat.getNumberInstance();
        numberFormat.setMinimumIntegerDigits(HEAD_SIZE);
        numberFormat.setGroupingUsed(false);

        // 协议头 byte 数组
        byte[] headByte = numberFormat.format(bodyByteLength).getBytes();

        // 封装协议头
        System.arraycopy(headByte, 0, result, 0, HEAD_SIZE);

        // 封装协议体
        System.arraycopy(bodyByte, 0, result, HEAD_SIZE, bodyByteLength);
        
        return result;
    }
    public int getHeader(InputStream inputStream) throws IOException {
        int result = 0;
        byte[] bytes = new byte[HEAD_SIZE];
        inputStream.read(bytes, 0, HEAD_SIZE); // 得到消息体的字节长度
        result = Integer.valueOf(new String(bytes));
        return result;
    }
}

 客户端代码：

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Random;

public class MySocketClient {
    public static void main(String[] args) throws IOException {
        // 启动 Socket 并尝试连接服务器
        Socket socket = new Socket("127.0.0.1", 9093);

        // 发送消息合集(随机发送一条消息)
        final String[] messages = {"hello world"};

        // 创建协议封装对象
        SocketPacket socketPacket = new SocketPacket();
        
        try (OutputStream outputStream = socket.getOutputStream()) {
            // 给服务器端发送 10 次消息
            for (int i = 0; i < 10; i++) {
                // 随机发送一条消息
                String msg = messages[new Random().nextInt(messages.length)];
                
                // 将内容封装为:协议头+协议体
                byte[] bytes = socketPacket.toBytes(msg);
                
                // 发送消息
                outputStream.write(bytes, 0, bytes.length);
                outputStream.flush();
            }
        }
    }
}

服务器端代码： 

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class MySocketServer {
    public static void main(String[] args) throws IOException {
        // 创建 Socket 服务器端
        ServerSocket serverSocket = new ServerSocket(9093);

        // 使用线程池处理更多的客户端
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(100, 150, 100, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000));

        while (true) {
            // 获取客户端连接
            Socket clientSocket = serverSocket.accept();

            // 客户端消息处理
            threadPool.submit(() -> {
                processMessage(clientSocket);
            });
        }
    }

    // 客户端消息处理
    private static void processMessage(Socket clientSocket) {
        // Socket 封装对象
        SocketPacket socketPacket = new SocketPacket();

        // 获取客户端发送的消息对象
        try (InputStream inputStream = clientSocket.getInputStream()) {
            while (true) {
                // 获取消息头(也就是消息体的长度)
                int bodyLength = socketPacket.getHeader(inputStream);

                // 消息体 byte 数组
                byte[] bodyByte = new byte[bodyLength];

                // 每次实际读取字节数
                int readCount = 0;

                // 消息体赋值下标
                int bodyIndex = 0;

                // 循环接收消息头中定义的长度
                while (bodyIndex <= (bodyLength - 1) && (readCount = inputStream.read(bodyByte, bodyIndex, bodyLength)) != -1) {
                    bodyIndex += readCount;
                }

                bodyIndex = 0;

                // 成功接收到客户端的消息并打印
                System.out.println("接收到客户端的信息:" + new String(bodyByte));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

 优缺点分析：

 此解决方案虽然可以解决粘包问题，但消息的设计和代码的实现复杂度比较高，所以也不是理想的解决方案

解决方案三：特殊字符结尾

以特殊字符结尾就可以知道流的边界了，它的具体实现是：使用Java 中自带的 BufferedReader 和Bufferedwriter ，也就是带缓冲区的输入字符流和输出字符流，通过写入的时候加上 \n 来结尾，读取的时候使用 readLine按行来读取数据，这样就知道流的边界了，从而解决了粘包的问题

服务器端代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ServerSocketV3 {
    public static void main(String[] args) throws IOException {
        // 创建 Socket 服务器端
        ServerSocket serverSocket = new ServerSocket(9092);

        // 使用线程池处理更多的客户端
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(100, 150, 100, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000));

        while (true) {
            // 获取客户端连接
            Socket clientSocket = serverSocket.accept();

            // 消息处理
            threadPool.submit(() -> {
                processMessage(clientSocket);
            });
        }
    }

    // 消息处理
    private static void processMessage(Socket clientSocket) {
        // 获取客户端发送的消息流对象
        try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()))) {
            while (true) {
                // 按行读取客户端发送的消息
                String msg = bufferedReader.readLine();
                if (msg != null) {
                    // 成功接收到客户端的消息并打印
                    System.out.println("接收到客户端的信息:" + msg);
                }
            }
        } catch (IOException ioException) {
            ioException.printStackTrace();
        }
    }
}

客户端代码：

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class ClientSocketV3 {
    public static void main(String[] args) throws IOException {
        // 启动 Socket 并尝试连接服务器
        Socket socket = new Socket("127.0.0.1", 9092);
        final String message = "hello world";

        // 发送消息
        try (BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()))) {
            // 给服务器端发送 10 次消息
            for (int i = 0; i < 10; i++) {
                // 注意:结尾的\n 不能省略,它表示按行写入
                bufferedWriter.write(message + "\n");

                // 刷新缓冲区(此步骤不能省略)
                bufferedWriter.flush();
            }
        }
    }
}

运行结果：

优缺点分析：

以特殊符号作为粘包的解决方案的最大优点是实现简单，但存在一定的局限性，比如当一条消息中间如果出现了结束符就会造成半包的问题，所以如果是复杂的字符串要对内容进行编码和解码处理，这样才能保证结束符的正确性

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1429779.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【C语言/基础梳理/期末复习】动态内存管理（附思维导图）

【C语言/基础梳理/期末复习】动态内存管理（附思维导图）

目录 一、为什么要有动态内存分配 &#xff08;1&#xff09;我们已经掌握的内存方式的特点 &#xff08;2&#xff09;需求 二、malloc和free 2.1.malloc 2.1.1函数原型 2.1.2函数使用 2.1.3应用示例​编辑 2.2free 2.2.1函数原型 2.2.2函数使用 三、calloc和reallo…
阅读更多...
算法练习-左叶子之和（思路+流程图+代码）

算法练习-左叶子之和（思路+流程图+代码）

难度参考 难度&#xff1a;中等 分类&#xff1a;二叉树 难度与分类由我所参与的培训课程提供&#xff0c;但需要注意的是&#xff0c;难度与分类仅供参考。且所在课程未提供测试平台&#xff0c;故实现代码主要为自行测试的那种&#xff0c;以下内容均为个人笔记&#xff0c;旨…
阅读更多...
rust gui开发框架选择

rust gui开发框架选择

作为一个系统编程强大语言&#xff0c;怎么能少得了图形界面的开发 实际上写这篇前我也不知道&#xff0c;于是我问了ai大模型&#xff0c;文心3.5和chatgpt4.0 答案实际上不能满意&#xff0c;最后我做了下筛选 参考博文&#xff1a; rust开发环境配置&#xff1a;链接 一、…
阅读更多...
Loadbalancer如何优雅分担服务负荷

Loadbalancer如何优雅分担服务负荷

欢迎来到我的博客&#xff0c;代码的世界里&#xff0c;每一行都是一个故事 Loadbalancer如何优雅分担服务负荷 前言Loadbalancer基础&#xff1a;数字世界的分配大师1. 分发请求&#xff1a;2. 健康检查&#xff1a;3. 会话保持&#xff1a;4. 可伸缩性&#xff1a;5. 负载均衡…
阅读更多...
数据结构—基础知识：哈夫曼编码

数据结构—基础知识：哈夫曼编码

文章目录 数据结构—基础知识&#xff1a;哈夫曼编码哈夫曼编码的主要思想有关编码的概念哈夫曼编码满足两个性质&#xff1a; 数据结构—基础知识&#xff1a;哈夫曼编码 哈夫曼编码的主要思想 在进行数据压缩时&#xff0c;为了使压缩后的数据文件尽可能短&#xff0c;可采…
阅读更多...
二手电脑配置给你不一样的成就感

二手电脑配置给你不一样的成就感

回顾从小到大使用电脑、组装电脑到开发软硬件的经历&#xff0c;总是对二手电脑有着不一样的情感&#xff0c;近五年买过八台新电脑&#xff0c;一台是图像处理培训买的笔记本&#xff0c;一台是小孩上课的台式机&#xff0c;一台是老人的集成办卡电脑&#xff0c;还有一些工作…
阅读更多...
Vue3_基础使用_2

Vue3_基础使用_2

这节主要介绍&#xff1a;标签和组件的ref属性&#xff0c;父子组件间的传递值&#xff0c;ts的接口定义&#xff0c;vue3的生命周期 1.标签的ref属性。 1.1ref属性就是给标签打标识用的&#xff0c;相当于html的id&#xff0c;但是在vue3中用id可能会乱&#xff0c;下面是ref…
阅读更多...
跟着cherno手搓游戏引擎【18】抽象Shader、项目小修改

跟着cherno手搓游戏引擎【18】抽象Shader、项目小修改

抽象&#xff1a; Shader.h: #pragma once #include <string>namespace YOTO {class Shader {public:virtual~Shader()default;virtual void Bind()const0;virtual void UnBind()const0;static Shader* Create(const std::string& vertexSrc, const std::string&am…
阅读更多...
软考高项-机考相关介绍论文写作基础介绍

软考高项-机考相关介绍论文写作基础介绍

机考相关 初、中级（信息处理技术员除外）资格：基础知识和应用技术2个科目连考，基础知识科目最短作答时长90分钟,最长作答时长120分钟，2个科目作答总时长240分钟，考试结束前60分钟可交卷离场 历年论文考题
阅读更多...
java数据结构与算法刷题-----LeetCode15. 三数之和

java数据结构与算法刷题-----LeetCode15. 三数之和

java数据结构与算法刷题目录&#xff08;剑指Offer、LeetCode、ACM&#xff09;-----主目录-----持续更新(进不去说明我没写完)&#xff1a;https://blog.csdn.net/grd_java/article/details/123063846 解题思路 和LeetCode1.两数之和一样&#xff0c;但是这道题边界条件更多。…
阅读更多...
Flutter 各种Demo效果合集

Flutter 各种Demo效果合集

Flutter 各种Demo实现效果&#xff1a; github&#xff1a;GitHub - PangHaHa12138/FlutterDemo: Flutter 各种Demo效果合集 1&#xff1a;2种 仿朋友圈 效果,顶部拉伸 和 不拉伸 2&#xff1a;仿抖音上下滑动视频播放 3&#xff1a;视频直播&#xff08;使用的电视台的m3u…
阅读更多...
云计算基础（云计算概述）

云计算基础（云计算概述）

目录 一、云计算概述 1.1 云计算的概念 1.1.1 云计算解决的问题 1.1.2 云计算的概念 1.1.3 云计算的组成 1.2 云计算主要特征 1.2.1 按需自助服务 1.2.2 泛在接入 1.2.3 资源池化 1.2.4 快速伸缩性 1.2.5 服务可度量 1.3 云计算服务模式 1.3.1 软件即服务(Softwar…
阅读更多...
C#验证字符串是否包含汉字：用正则表达式 vs 用ASCII码 vs 用汉字的 Unicode 编码

C#验证字符串是否包含汉字：用正则表达式 vs 用ASCII码 vs 用汉字的 Unicode 编码

目录 一、使用的方法 1.使用正则表达式验证字符串 2.使用正则表达式验证字符 3.用ASCII码判断 4.用汉字的 Unicode 编码范围判断 二、实例 1.源码 2.生成效果 验证一个字符串是否是纯汉字或者包含有汉字的前提&#xff0c;是VS编辑器的默认编码格式设置为&#xff1a;选…
阅读更多...
Vite与Webpack打包内存溢出问题优雅处理方式

Vite与Webpack打包内存溢出问题优雅处理方式

Vite与Webpack打包内存溢出问题处理 文章目录 Vite与Webpack打包内存溢出问题处理1. Vite1. 打包错误提示2. 命令行方式解决3. 配置环境变量方式解决1. 设置变量2. 配置系统的环境变量 2. Webpack1. 打包错误提示2. 命令行方式解决3. 配置环境变量方式解决1. 设置变量2. 配置系…
阅读更多...
Llama2大模型开源，大模型的Android时代来了？

Llama2大模型开源，大模型的Android时代来了？

就昨天凌晨，微软和Meta宣布Llama2大模型开源且进一步放开商用，一下朋友圈刷屏。要知道，开源界最强大的模型就是过去Meta开源的Llama，而现在Llama2更强大，又开放商用，更有微软大模型霸主企业撑腰（微软既投资大模型界的IOS——ChatGPT，又联合发布大模型的Android——Llam…
阅读更多...
旧衣物回收小程序开发，互联网模式下的营收有多大？

旧衣物回收小程序开发，互联网模式下的营收有多大？

在当下快节奏的生活中&#xff0c;人们不仅生活水平在提高&#xff0c;消费水平也在逐渐提高&#xff0c;从而导致了闲置衣物的增加。为了减少浪费&#xff0c;旧衣服回收行业受到了大众的广泛关注&#xff0c;成为循环利用的一大方式。 当然&#xff0c;在当下网络时代&#…
阅读更多...
Docker 阿里云镜像仓库CR使用实践

Docker 阿里云镜像仓库CR使用实践

一、使用容器镜像&#xff0c;查看镜像&#xff0c;创建&#xff0c;推送&#xff0c;拉取阿里云镜像 CR镜像管理&#xff08;阿里云容器镜像服务&#xff08;Container Registry&#xff09;&#xff09; 登录实例 未创建的镜像名称也可以push、docker的私有仓库需要提起创建…
阅读更多...
C语言——深入理解指针（1）

C语言——深入理解指针（1）

目录 1.内存和地址 a 内存的理解 b 如何理解编址 2.指针变量和地址 a 取地址操作符 b 指针变量 c 解引用操作符 d 指针变量的大小 1.内存和地址 a 内存的理解 假想这样一个场景&#xff0c;你的朋友找你玩&#xff0c;到了你家小区&#xff0c;如何让她迅速的找到…
阅读更多...
时间复杂度为 O(n) 的排序算法

时间复杂度为 O(n) 的排序算法

大家好&#xff0c;我是 方圆。本文介绍线性排序&#xff0c;即时间复杂度为 O(n) 的排序算法&#xff0c;包括桶排序&#xff0c;计数排序和基数排序&#xff0c;它们都不是基于比较的排序算法&#xff0c;大家重点关注一下这些算法的适用场景。 桶排序 桶排序是分治策略的一…
阅读更多...
Sentinel应用笔记

Sentinel应用笔记

概念 当A、B、G、H掉线&#xff0c;其他服务就没法通信了 随着微服务的流行&#xff0c;服务和服务之间的稳定性变得越来越重要。Sentinel 以流量为切入点&#xff0c;从流量控制、流量路由、熔断降级、系统自适应过载保护、热点流量防护等多个维度保护服务的稳定性。 特性…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023