Golang网络Socket粘包问题的解决方法

什么是粘包

在 TCP 协议中，由于 Nagle 算法或发送/接收缓冲区的特性，多次小数据包可能合并为一个大包发出，或者一个大包被拆分为多个小包接收。从接收方缓冲区的视角看，后一包数据的头部紧接着前一包数据的尾部，导致无法直接区分消息边界，即所谓的“粘包”。

核心解决方案

最通用的做法是采用 Length-Prefixed 编码模式：先发送表示消息体长度的 4 字节整数，再发送实际的消息体。

服务端：解析消息头与缓冲切割

服务端需要维护一个消息缓冲区和一个数据读取缓冲区。主要逻辑分为三步：读取原始数据到缓冲区、尝试读取并解析消息头、当缓冲区数据足够时按长度提取完整消息体。

1. 初始化环境：监听端口并启动协程处理连接。
2. 建立缓冲池：使用 bytes.Buffer 累积不完整的数据包。
3. 读取与解析：

• 若当前无正在解析的消息 (length == 0)，且缓冲区至少有 4 字节，则读取消息长度。
• 检查长度有效性（如超过限制可直接断开连接）。
• 进入子循环：判断缓冲区剩余长度是否 >= 消息体长度。
• 若满足，使用 Next(length) 切出消息并处理；若不满足，跳出内层循环等待新数据到达。

package main
import (
    "bytes"
    "encoding/binary"
    "fmt"
    "io"
    "net"
)
func main() {
    // 监听端口
    ln, err := net.Listen("tcp", ":6000")
    if err != nil {
        fmt.Printf("Listen Error: %s\n", err)
        return
    }
    // 监听循环
    for {
        // 接受客户端链接
        conn, err := ln.Accept()
        if err != nil {
            fmt.Printf("Accept Error: %s\n", err)
            continue
        }
        // 处理客户端链接
        go handleConnection(conn)
    }
}
func handleConnection(conn net.Conn) {
    // 关闭链接
    defer conn.Close()
    // 客户端
    fmt.Printf("Client: %s\n", conn.RemoteAddr())
    // 消息缓冲
    msgbuf := bytes.NewBuffer(make([]byte, 0, 10240))
    // 数据缓冲
    databuf := make([]byte, 4096)
    // 消息长度
    length := 0
    // 消息长度uint32
    ulength := uint32(0)
    // 数据循环
    for {
        // 读取数据
        n, err := conn.Read(databuf)
        if err == io.EOF {
            fmt.Printf("Client exit: %s\n", conn.RemoteAddr())
        }
        if err != nil {
            fmt.Printf("Read error: %s\n", err)
            return
        }
        fmt.Println(databuf[:n])
        // 数据添加到消息缓冲
        n, err = msgbuf.Write(databuf[:n])
        if err != nil {
            fmt.Printf("Buffer write error: %s\n", err)
            return
        }
        // 消息分割循环
        for {
            // 消息头
            if length == 0 && msgbuf.Len() >= 4 {
                binary.Read(msgbuf, binary.LittleEndian, &ulength)
                length = int(ulength)
                // 检查超长消息
                if length > 10240 {
                    fmt.Printf("Message too length: %d\n", length)
                    return
                }
            }
            // 消息体
            if length > 0 && msgbuf.Len() >= length {
                fmt.Printf("Client messge: %s\n", string(msgbuf.Next(length)))
                length = 0
            } else {
                break
            }
        }
    }
}

客户端：构建并发粘包测试数据

为了验证上述方案的鲁棒性，客户端应当模拟多种极端情况下的发包过程，包括：单包发送多条消息、不连续分包发送以及部分发送消息头和消息体。

1. 封装协议：定义消息内容为 UTF-8 字符串，计算其字节长度 messageLen。
2. 组装缓冲：将 messageLen (4字节) 与 message 拼接写入 msgbuf。循环写入10条这样的数据。
3. 构造粘包场景：

• 正常发送：一次性写出单条或多条完整消息。
• 截断发送：先写 2 字节（仅部分消息头），休眠后补全剩余部分。
• 乱序/混合发送：穿插不同长度的碎片化 Write 操作。

package main
import (
    "bytes"
    "encoding/binary"
    "fmt"
    "net"
    "time"
)
func main() {
    // 链接服务器
    conn, err := net.Dial("tcp", "127.0.0.1:6000")
    if err != nil {
        fmt.Printf("Dial error: %s\n", err)
        return
    }
    // 客户端信息
    fmt.Printf("Client: %s\n", conn.LocalAddr())
    // 消息缓冲
    msgbuf := bytes.NewBuffer(make([]byte, 0, 1024))
    // 消息内容
    message := []byte("我是utf-8的消息")
    // 消息长度
    messageLen := uint32(len(message))
    // 消息总长度
    mlen := 4 + len(message)
    // 写入5条消息
    for i := 0; i < 10; i++ {
        binary.Write(msgbuf, binary.LittleEndian, messageLen)
        msgbuf.Write(message)
    }
    // 单包发送一条消息
    conn.Write(msgbuf.Next(mlen))
    time.Sleep(time.Second)
    // 单包发送三条消息
    conn.Write(msgbuf.Next(mlen * 3))
    time.Sleep(time.Second)
    // 发送不完整的消息头
    conn.Write(msgbuf.Next(2))
    time.Sleep(time.Second)
    // 发送消息剩下部分
    conn.Write(msgbuf.Next(mlen - 2))
    time.Sleep(time.Second)
    // 发送不完整的消息体
    conn.Write(msgbuf.Next(mlen - 6))
    time.Sleep(time.Second)
    // 发送消息剩下部分
    conn.Write(msgbuf.Next(6))
    time.Sleep(time.Second)
    // 多段发送
    conn.Write(msgbuf.Next(mlen + 2))
    time.Sleep(time.Second)
    conn.Write(msgbuf.Next(-2 + mlen - 8))
    time.Sleep(time.Second)
    conn.Write(msgbuf.Next(8 + 1))
    time.Sleep(time.Second)
    conn.Write(msgbuf.Next(-1 + mlen + mlen))
    time.Sleep(time.Second)
    // 关闭链接
    conn.Close()
}

以上就是 Go 语言网络 Socket 粘包问题的详细内容，更多关于 Go 语言 socket 通讯的资料请关注本站其它相关文章！