欢迎光临
我们一直在努力

Qt中解决粘包问题

非AI生成,觉得有用,就请您帮忙点赞转发收藏吧,您的鼓励是我创作的动力,多谢看官。

目录

一、什么是粘包问题

二、什么情况下容易出现粘包问题

三、解决粘包问题的常用办法

1.包头+包体

2.固定数据长度

3.使用特殊符号分隔

四、粘包问题示例      

1.展示粘包问题

2.解决粘包问题

五、Qt使用多线程解决粘包问题的示例(包含核心代码)

六、有哪些开源库能解决粘包问题

七、总结

八、参考链接


一、什么是粘包问题

粘包问题是指 TCP 通信中,发送端多次独立发送的数据包,在接收端被合并成一次读取或边界模糊,导致无法区分原始消息边界的现象 。‌‌例如服务端发送两条数据,客户端没有收到两次,一次都把两条数据收到了;或者收到了数据的一部分,数据的另外一部分是后续收到的。

二、什么情况下容易出现粘包问题

在数据量小、收发不频繁的情况,可能不做什么处理,也能收到完整的数据,一旦数据量比较大、收发非常频繁的情况下,就极容易出现粘包问题。

 发送端启用Nagle 算法:

连续多次发送小数据(间隔短、体积小),TCP 为优化效率将其合并为一个段发送,导致接收方一次性收到多条逻辑消息 。

接收端处理延迟 :

应用层未及时调用 recv 读取缓冲区,后续数据持续涌入,导致多条消息在缓冲区粘连,下次读取时一并取出 。

单次发送数据超过MTU:

大数据包被底层拆片传输,若重组时机与下一条消息到达时间重叠,可能呈现为“粘包”现象(实为拆包重组后的连续流)。

未定义应用层协议边界:

缺乏长度前缀、分隔符等机制,接收方无法判断消息起止位置,将连续字节流误判为单一消息 

三、解决粘包问题的常用办法

1.包头+包体

协议格式:

| 包头(4字节长度) | 包体(N字节) |

优点:

二进制安全 不浪费带宽 可扩展 工业标准

发送端代码

void sendPacket(QTcpSocket *socket, const QByteArray &body)
{
QByteArray packet;
QDataStream ds(&packet, QIODevice::WriteOnly);
ds << quint32(body.size()); // 包头
packet.append(body); // 包体
socket->write(packet);
}

接收端代码

QByteArray recvBuffer;

void onReadyRead()
{
recvBuffer.append(socket->readAll());

while (recvBuffer.size() >= 4) {
const quint32 len =
qFromBigEndian(*reinterpret_cast<const quint32*>(
recvBuffer.constData()));

if (recvBuffer.size() < 4 + len)
return; // 数据未收齐

QByteArray packet = recvBuffer.mid(4, len);
processPacket(packet);

recvBuffer.remove(0, 4 + len);
}
}

2.固定数据长度

协议格式:

每条消息固定 N 字节

优点:

实现简单

不用维护复杂状态

缺点:

浪费带宽 不灵活 不适合变长数据

const int PACKET_SIZE = 64;

void onReadyRead()
{
static QByteArray buffer;
buffer.append(socket->readAll());

while (buffer.size() >= PACKET_SIZE) {
QByteArray packet = buffer.left(PACKET_SIZE);
processPacket(packet);
buffer.remove(0, PACKET_SIZE);
}
}

3.使用特殊符号分隔

协议格式:

MSG1\\nMSG2\\nMSG3\\n

优点:

实现简单

人类可读

调试友好

缺点:

二进制不安全

数据里不能出现分隔符

需要转义

QByteArray buffer;

void onReadyRead()
{
buffer.append(socket->readAll());

while (buffer.contains('\\n')) {
int idx = buffer.indexOf('\\n');
QByteArray msg = buffer.left(idx);
buffer.remove(0, idx + 1);

processMsg(msg);
}
}

四、粘包问题示例      

1.展示粘包问题

第一次收到的数据:

{"CmdType":"","MsgId":995,"SendTime":"2026-07-08 17:32::56.839","Sender":"Server","Total":269633}{"CmdType":"","MsgId":996,"SendTime":"2026-07-08 17:32::56.839","Sender":"Server","Total":995866}{"CmdType":"","MsgId":997,"SendTime":"2026-07-08 17:32::56

第二次收到的数据:

.839","Sender":"Server","Total":499067}{"CmdType":"","MsgId":998,"SendTime":"2026-07-08 17:32::56.839","Sender":"Server","Total":536477}{"CmdType":"","MsgId":999,"SendTime":"2026-07-08 17:32::56.839","Sender":"Server","Total":192573}{"CmdType":"","MsgId":1000,"SendTime":"2026-07-08 17:32::56.839","Sender":"Server","Total":483860}

2.解决粘包问题

正常处理了510’000条数据

五、Qt使用多线程解决粘包问题的示例(包含核心代码)

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QTcpServer>
#include <QTcpSocket>
#include <QPointer>
#include <QMessageBox>
#include <QMutex>
#include <QMap>
#include <QUuid>
#include <QRandomGenerator>

#include "Utility.h"
#include "CustomMessage.h"
#include "Receiver.h"

QT_BEGIN_NAMESPACE
namespace Ui {
class MainWindow;
}
QT_END_NAMESPACE

class MainWindow : public QMainWindow
{
Q_OBJECT

public:
MainWindow(QWidget *parent = nullptr);
~MainWindow();

private slots:
void on_btnSwitchServer_clicked();

private:
Ui::MainWindow *ui;
QTcpServer* m_tcpSrv = nullptr;
bool m_isListening = false;
QMap<QPointer<QTcpSocket>,QString> m_clients;

private:
QPointer<QTcpSocket> m_client = nullptr;
bool m_isConnected = false;
int m_sentMsgCount = 0;

bool m_isReceiving = false;
QPointer<QThread> m_receiverThread = nullptr;
QPointer<Receiver> m_receiver = nullptr;

QAtomicInt m_processedFrames{0};

private:
void startReceiverThread();
void stopReceiverThread();

void startTcpServer();
void stopTcpServer();

void connectToServer();
void disconnectFromServer();

void sendMessage(int num);

private slots:
void onMessageReceived(const QString &msg="",int index=1);

void on_btnSendMessage_clicked();
void on_btnClear_clicked();
void handleNewConnection();

void onDisconnected();

void on_btnConnectToClient_clicked();

void on_btnClear2_clicked();

void on_btnSendSingle_clicked();

protected:
void closeEvent(QCloseEvent *event) override;

signals:
void requestStop();
void dataReady(const QByteArray& data);
};
#endif // MAINWINDOW_H

#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
{
ui->setupUi(this);
}

MainWindow::~MainWindow()
{
delete ui;
}

void MainWindow::startTcpServer()
{
if(!m_tcpSrv){
m_tcpSrv = new(std::nothrow) QTcpServer(this);
}
QString addr = ui->tbServerIP->text().simplified();
if(addr.isEmpty()){
QMessageBox::warning(this,"系统提示","服务地址不能为空");
return;
}
QHostAddress address(addr);
bool ok = false;
quint16 port = ui->tbServerPort->text().toUShort(&ok,10);
m_isListening = m_tcpSrv->listen(address,port);
if(m_isListening){
ui->btnSwitchServer->setText("关闭服务");
}
QString msg = QString("%1 启动Tcp服务端 %2").arg(Utility::getNowTimeStrWithMs()).arg(m_isListening?"成功":"失败");
onMessageReceived(msg);

//连接信号槽
connect(m_tcpSrv,&QTcpServer::newConnection,this,&MainWindow::handleNewConnection);
}

void MainWindow::onMessageReceived(const QString &msg,int index)
{
static QMutex mutex;
QMutexLocker<QMutex> locker(&mutex);
if(index==1){
ui->tbLog->appendPlainText(msg);
}
else{
ui->tbLog2->appendPlainText(msg);
}
}

void MainWindow::stopTcpServer()
{
if(!m_tcpSrv){return;}
m_tcpSrv->close();
m_tcpSrv->disconnect();
QString msg = QString("%1 关闭Tcp服务端 成功").arg(Utility::getNowTimeStrWithMs());
onMessageReceived(msg);
m_isListening = false;
ui->btnSwitchServer->setText("启动服务");
for(auto &socket:m_clients.keys()){
socket->disconnectFromHost();
}
//m_tcpSrv->destroyed();
}

void MainWindow::connectToServer()
{
if(!m_client){
m_client = new QTcpSocket(this);
}
QString addr = ui->tbServerIP->text().simplified();
if(addr.isEmpty()){
QMessageBox::warning(this,"系统提示","服务地址不能为空");
return;
}
QHostAddress address(addr);
bool ok = false;
quint16 port = ui->tbServerPort->text().toUShort(&ok,10);
m_client->connectToHost(address,port);

//绑定信号槽
connect(m_client,&QTcpSocket::connected,this,[=](){
m_isConnected = true;
QString msg = QString("%1 连接Tcp服务端 成功").arg(Utility::getNowTimeStrWithMs());
onMessageReceived(msg,2);
ui->btnConnectToClient->setText("断开服务端");
});

connect(m_client,&QTcpSocket::errorOccurred,this,[=](QAbstractSocket::SocketError error){
QString msg = QString("%1 连接Tcp服务端 发生错误,错误编号:%2").arg(Utility::getNowTimeStrWithMs()).arg(error);
onMessageReceived(msg,2);
});

connect(m_client,&QTcpSocket::readyRead,this,[=](){
QByteArray data = m_client->readAll();
QString msg = QString("%1 收到服务端数据:%2,长度:%3 字节").arg(Utility::getNowTimeStrWithMs()).arg(data).arg(data.size());
onMessageReceived(msg,2);

//发给线程处理
QMetaObject::invokeMethod(m_receiver,"appendData",Qt::DirectConnection,Q_ARG(QByteArray,data));
});

connect(m_client,&QTcpSocket::disconnected,this,[=](){
m_isConnected = false;
QString msg = QString("%1 Tcp服务端连接 已断开").arg(Utility::getNowTimeStrWithMs());
onMessageReceived(msg,2);
ui->btnConnectToClient->setText("连接服务端");
});

connect(m_client,&QTcpSocket::disconnected,m_client,&QTcpSocket::deleteLater);
}

void MainWindow::disconnectFromServer()
{
if(m_client){
m_client->disconnectFromHost();
m_client->deleteLater();
m_client = nullptr;
}
}

void MainWindow::sendMessage(int num)
{
if(!m_isListening){
QMessageBox::information(this,"系统提示","请先启动服务端");
return;
}
if(m_clients.count() == 0){
QMessageBox::information(this,"系统提示","当前的客户端连接数为0");
return;
}
QString message;
CustomMessage custMsg;
QByteArray data;
thread_local QRandomGenerator rng(QRandomGenerator::securelySeeded());
for(int i=1;i<=num;++i){
custMsg.CmdType = "";
custMsg.MsgId = i;//QUuid::createUuid().toString(QUuid::WithoutBraces)
custMsg.Sender = "Server";
custMsg.SendTime = Utility::getNowTimeStrWithMs();
custMsg.Total = rng.bounded(1,1'000'000);//QRandomGenerator::global()在循环内不够随机
message = Utility::toString(custMsg);
data = message.toUtf8();
data = Utility::addFrameHeader(data,data.size());
for(auto &socket:m_clients.keys()){
socket->write(data);
//socket->flush();
//socket->waitForBytesWritten(100);
}
}
m_sentMsgCount += num;
message = QString("%1 已成功发送%2条测试消息,总发送数:%3").arg(Utility::getNowTimeStrWithMs()).arg(num).arg(m_sentMsgCount);
onMessageReceived(message,1);
}

void MainWindow::on_btnSwitchServer_clicked()
{
if(m_isListening){
stopTcpServer();
}
else{
startTcpServer();
}
}

void MainWindow::startReceiverThread()
{
m_receiverThread = new QThread;
m_receiver = new Receiver(nullptr);
if(m_receiverThread && m_receiver){
//绑定信号槽
connect(m_receiver,&Receiver::messageReceived,this,&MainWindow::onMessageReceived,Qt::QueuedConnection);
connect(m_receiverThread,&QThread::started,m_receiver,&Receiver::Start);//线程已启动,工作对象就开始干活
connect(m_receiver,&Receiver::frameProcessed,this,[=](){
m_processedFrames.fetchAndAddRelaxed(1);
ui->lblProcessedMsg->setText(QString::number(m_processedFrames.loadRelaxed()));
});

connect(m_receiver,&Receiver::finished,m_receiver,&Receiver::deleteLater);//工作线程执行完就释放

connect(m_receiver,&Receiver::finished,m_receiverThread,&QThread::quit);//工作对象执行完就退出线程

connect(m_receiverThread,&QThread::finished,m_receiverThread,&QThread::deleteLater);//释放线程对象

connect(this,&MainWindow::requestStop,m_receiver,&Receiver::Stop,Qt::QueuedConnection);
connect(this,&MainWindow::dataReady,m_receiver,&Receiver::appendData,Qt::QueuedConnection);

m_receiver->moveToThread(m_receiverThread);
m_receiverThread->start();
}
}

void MainWindow::stopReceiverThread()
{
if(m_receiver){
//QMetaObject::invokeMethod(m_receiver,"Stop",Qt::DirectConnection);
//m_receiver->Stop();
isRunning.storeRelaxed(false);
bufferNotEmpty.wakeAll();
}
}

void MainWindow::on_btnSendMessage_clicked()
{
sendMessage(1000);
}

void MainWindow::on_btnSendSingle_clicked()
{
sendMessage(1);
}

void MainWindow::on_btnClear_clicked()
{
ui->tbLog->clear();
}

void MainWindow::handleNewConnection()
{
QTcpSocket* socket = m_tcpSrv->nextPendingConnection();
QString clientAddr = socket->peerAddress().toString();
quint16 clientPort = socket->peerPort();
m_clients.insert(socket,clientAddr);
//使用Lambda需注意,在收到QTcpSocket::disconnected信号时,UI控件可能因关闭窗口已释放,这时就可能访问已释放内存(段错误)
//解决办法:关闭窗口前,断开QTcpSocket的信号槽连接
connect(socket,&QTcpSocket::disconnected,this,[=](){
QString msg = QString("%1 客户端%2:%3 已断开").arg(Utility::getNowTimeStrWithMs()).arg(clientAddr).arg(clientPort);
onMessageReceived(msg);
m_clients.remove(socket);

msg = QString("%1 客户端连接数量:%2").arg(Utility::getNowTimeStrWithMs()).arg(m_clients.count());
onMessageReceived(msg);
});
connect(socket, &QTcpSocket::disconnected,socket, &QObject::deleteLater);
QString msg = QString("%1 客户端%2:%3 已连接").arg(Utility::getNowTimeStrWithMs()).arg(clientAddr).arg(clientPort);
onMessageReceived(msg);

msg = QString("%1 客户端连接数量:%2").arg(Utility::getNowTimeStrWithMs()).arg(m_clients.count());
onMessageReceived(msg);
}

void MainWindow::onDisconnected()
{
}

void MainWindow::closeEvent(QCloseEvent *event)
{
Q_UNUSED(event)
for(auto &socket:m_clients.keys()){
socket->disconnect();
socket->disconnectFromHost();
}
}

void MainWindow::on_btnConnectToClient_clicked()
{
if(!m_client || !m_isConnected){
if(m_client){
m_client->disconnect();
}
connectToServer();
if(!m_receiverThread){
startReceiverThread();
}
}
else{
disconnectFromServer();
if(m_receiver){
stopReceiverThread();
}
}
}

void MainWindow::on_btnClear2_clicked()
{
ui->tbLog2->clear();
}

六、有哪些开源库能解决粘包问题

1. HP-Socket(⭐⭐⭐⭐⭐ 强烈推荐,国内用得多)

跨平台(Win / Linux / Mac 等),高性能

内置粘包拆包、心跳、重连、缓冲区管理

支持:

长度字段拆包

固定长度

分隔符

提供 C/C++ / C# / Java / Python 等 API

商业项目用得非常多,稳定性经过验证

2. libhv

类 libevent / muduo 风格的高性能 C/C++ 网络库

TCP 组件内置 UNPACK_BY_LENGTH_FIELD / 分隔符 / 固定长度​ 三种拆包模式

几行配置就能解决 90% 的粘包问题,不需要自己写 while(buffer.size()>=4)

3. muduo(陈硕)

基于 Reactor,Buffer 类内置 TCP 流缓冲

虽然不直接叫“拆包器”,但它的 Buffer::peekInt32()+ retrieve()就是为你做长度前缀拆包准备的

很多公司内网框架的拆包逻辑都参考它

4. Boost.Asio + st_asio_wrapper

Boost.Asio 本身只提供字节流

st_asio_wrapper​ 在 Asio 之上封装了:

自动粘包处理

可配置长度前缀 / 分隔符 / 固定包长

packer / unpacker 接口可自定义(JSON / Protobuf / TLV 等)

5. yasio(游戏 / 客户端向)

轻量跨平台异步 socket 库

内置 TCP 粘包处理

支持 Header + Body、二进制流、7Bit 变长整数

常用于 Cocos / Unity / UE 客户端网络层

七、总结

粘包问题不是 TCP 的问题,而是“应用层忘记定义消息边界”的问题。

✅ TCP 只负责送字节

✅ 你怎么“切”字节,是你的事

✅ 不切,就会粘

八、参考链接

1.Qt线程同步之QWaitCondition

赞(0)
未经允许不得转载:171主机测评 » Qt中解决粘包问题
分享到: 更多 (0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址