腾讯一面：TCP的黏包怎么解决？

千羽

发布于 2024-02-21 17:19:47

1440

发布于 2024-02-21 17:19:47

文章被收录于专栏：程序员千羽程序员千羽

hello，大家好，我是千羽。

今天来分析一下我当时面腾讯一面的一道面试题：TCP的黏包怎么解决？

其实这是一个很常见的问题。当时的靠着背八股文通过了一面hhh。

最近看到golang有对这方面的处理，下面可以一起探讨一下tcp黏包的问题。

什么是TCP黏包?

在TCP网络通信中，粘包（sticky packet）是一个常见的现象。

当多个逻辑上的数据包被封装在一个TCP数据包中进行传输时，接收端可能会一次性接收到多个数据包的内容，或者将多个逻辑上的数据包拆分成多个TCP数据包进行接收，这就是所谓的TCP粘包现象。

先来一段代码看看效果：

client/main.go

package main

import (
   "fmt"
   "golang/day6_network/tcp_sticky_package"
   "net"
)

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 := tcp_sticky_package.Encode(msg)
      if err != nil {
         fmt.Println("encode msg failed, err:", err)
         return
      }
      conn.Write(data)
   }
}

server/main.go

package main

import (
   "bufio"
   "fmt"
   "io"
   "net"
)

func process(conn net.Conn) {
   defer conn.Close()
   reader := bufio.NewReader(conn)
   var buf [1024]byte
   for {
      n, err := reader.Read(buf[:])
      if err == io.EOF {
         break
      }
      if err != nil {
         fmt.Println("read from client failed, err:", err)
         break
      }
      recvStr := string(buf[:n])
      fmt.Println("收到client发来的数据：", recvStr)
   }
}

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) // 开启一个协程来处理请求
   }
}

将上面的代码保存后，分别编译。先启动服务端再启动客户端，可以看到服务端输出结果如下：

收到client发来的数据：Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?
收到client发来的数据：Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?
收到client发来的数据：Hello, Hello. How are you?Hello, Hello. How are you?
收到client发来的数据：Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?
收到client发来的数据：Hello, Hello. How are you?Hello, Hello. How are you?

客户端分10次发送的数据，在服务端并没有成功的输出10次，而是多条数据“粘”到了一起。

为什么会出现粘包?

主要原因就是TCP是一个面向字节流的协议，没有明确的消息边界。发送方发送的数据被封装在一个TCP数据流中，接收方无法直接判断每个数据包的边界。

“粘包”可发生在发送端也可发生在接收端：

1.由Nagle算法造成的发送端的粘包：Nagle算法是一种改善网络传输效率的算法。简单来说就是当我们提交一段数据给TCP发送时，TCP并不立刻发送此段数据，而是等待一小段时间看看在等待期间是否还有要发送的数据，若有则会一次把这两段数据发送出去。
2.接收端接收不及时造成的接收端粘包：TCP会把接收到的数据存在自己的缓冲区中，然后通知应用层取数据。当应用层由于某些原因不能及时的把TCP的数据取出来，就会造成TCP缓冲区中存放了几段数据。

解决办法

出现”粘包”的关键在于接收方不确定将要传输的数据包的大小，因此我们可以对数据包进行封包和拆包的操作。

封包：封包就是给一段数据加上包头，这样一来数据包就分为包头和包体两部分内容了(过滤非法包时封包会加入”包尾”内容)。包头部分的长度是固定的，并且它存储了包体的长度，根据包头长度固定以及包头中含有包体长度的变量就能正确的拆分出一个完整的数据包。

我们可以自己定义一个协议，比如数据包的前4个字节为包头，里面存储的是发送的数据的长度。

package tcp_sticky_package

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
}

接下来在服务端和客户端分别使用上面定义的proto包的Decode和Encode函数处理数据。

client2/main.go

package main

import (
   "fmt"
   "golang/day6_network/tcp_sticky_package"
   "net"
)

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 := tcp_sticky_package.Encode(msg)
      if err != nil {
         fmt.Println("encode msg failed, err:", err)
         return
      }
      conn.Write(data)
   }
}

server2/main.go

package main

import (
   "bufio"
   "fmt"
   "golang/day6_network/tcp_sticky_package"
   "io"
   "net"
)

func process(conn net.Conn) {
   defer conn.Close()
   reader := bufio.NewReader(conn)

   for {
      msg, err := tcp_sticky_package.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) // 开启一个协程来处理请求
   }
}

总结

为了解决TCP粘包问题，我们可以采取以下几种方法：

定长报文：发送方和接收方约定好每个数据包的长度，接收方按照约定的长度来读取数据。
特殊字符分隔：发送方在每个数据包之间加入一个或多个特殊字符作为分隔符，接收方通过识别这些特殊字符来确定数据包的边界。例如，可以使用换行符\n或回车符\r作为分隔符。
头部信息：在每个数据包的开头添加一段头部信息，包括数据包的长度、类型等信息。
协议解析：对于一些特定的协议，如HTTP、FTP等，它们有自己的协议解析方式，可以很好地解决TCP粘包问题。

参考文献：https://www.topgoer.com/%E7%BD%91%E7%BB%9C%E7%BC%96%E7%A8%8B/socket%E7%BC%96%E7%A8%8B/TCP%E9%BB%8F%E5%8C%85.html

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2024-02-10，如有侵权请联系 cloudcommunity@tencent.com 删除

协议