TCP粘包

什么是TCP粘包问题

多个TCP包粘在一个成为一个包，服务端处理接收的TCP包时，需要考虑拆包问题。

产生原因

• 发送端，如果发送端短时间发送多个小包，TCP默认使用Nagle算法，将短时间的多个小包合并为一个大包发送给服务端
• 接收端，接收端接收的TCP并不会立即传给应用层处理，而是保存在缓存中，应用层会主动去缓存中取数据处理，如果有多个包别缓存，应用层一次就会拿多个包

什么时候考虑粘包问题

• 如果是一个整体数据被拆成多个包发送，一般不需要考虑粘包问题
• 多个不相同数据的包粘在一起，即需要特别处理

如何处理粘包

• 发送端，可以关闭粘包功能，使用TCP_NODELAY选项来关闭Nagle算法
• 接收端，接收端缓存问题造成的粘包无法处理
• 解决办法：从应用层处理，
  1：将发送数据重新封装，把每个TCP包的长度封装上去
  2：接收端将接收的数据重新解析

参考代码Go语言版本：
在原始发送数据的前增加发送数据长度部分
传输数据加密和解密

// socket_stick/proto/proto.go
package proto

import (
    "bufio"
    "bytes"
    "encoding/binary"
)

// Encode 将消息编码
func Encode(message string) ([]byte, error) {
    // 读取消息的长度，转换成int32类型（占4个字节）
    var length = int32(len(message))
    var pkg = new(bytes.Buffer)
    // 写入消息头
    err := binary.Write(pkg, binary.LittleEndian, length)
    if err != nil {
        return nil, err
    }
    // 写入消息实体
    err = binary.Write(pkg, binary.LittleEndian, []byte(message))
    if err != nil {
        return nil, err
    }
    return pkg.Bytes(), nil
}

// Decode 解码消息
func Decode(reader *bufio.Reader) (string, error) {
    // 读取消息的长度
    lengthByte, _ := reader.Peek(4) // 读取前4个字节的数据
    lengthBuff := bytes.NewBuffer(lengthByte)
    var length int32
    err := binary.Read(lengthBuff, binary.LittleEndian, &length)
    if err != nil {
        return "", err
    }
    // Buffered返回缓冲中现有的可读取的字节数。
    if int32(reader.Buffered()) < length+4 {
        return "", err
    }

    // 读取真正的消息数据
    pack := make([]byte, int(4+length))
    _, err = reader.Read(pack)
    if err != nil {
        return "", err
    }
    return string(pack[4:]), nil
}

服务端代码：

// socket_stick/server2/main.go

func process(conn net.Conn) {
    defer conn.Close()
    reader := bufio.NewReader(conn)
    for {
        msg, err := proto.Decode(reader)
        if err == io.EOF {
            return
        }
        if err != nil {
            fmt.Println("decode msg failed, err:", err)
            return
        }
        fmt.Println("收到client发来的数据：", msg)
    }
}

func main() {

    listen, err := net.Listen("tcp", "127.0.0.1:30000")
    if err != nil {
        fmt.Println("listen failed, err:", err)
        return
    }
    defer listen.Close()
    for {
        conn, err := listen.Accept()
        if err != nil {
            fmt.Println("accept failed, err:", err)
            continue
        }
        go process(conn)
    }
}

客户端代码：

// socket_stick/client2/main.go

func main() {
    conn, err := net.Dial("tcp", "127.0.0.1:30000")
    if err != nil {
        fmt.Println("dial failed, err", err)
        return
    }
    defer conn.Close()
    for i := 0; i < 20; i++ {
        msg := `Hello, Hello. How are you?`
        data, err := proto.Encode(msg)
        if err != nil {
            fmt.Println("encode msg failed, err:", err)
            return
        }
        conn.Write(data)
    }
}

UDP会不会有粘包问题

不会
TCP是面向连接的，为了性能，采用基于流的传输，基于流的传输，不会认为数据是一条条的，没有保护数据的边界，
UDP则是面向消息传输的，有保护消息边界，所以不存在粘包温恩提