Golang TCP粘包拆包问题的解决方法

程序员文章站 2022-04-28 17:06:09

什么是粘包问题最近在使用golang编写socket层，发现有时候接收端会一次读到多个数据包的问题。于是通过查阅资料，发现这个就是传说中的tcp粘包问题。下面通过编...

什么是粘包问题

最近在使用golang编写socket层，发现有时候接收端会一次读到多个数据包的问题。于是通过查阅资料，发现这个就是传说中的tcp粘包问题。下面通过编写代码来重现这个问题：

服务端代码 server/main.go

func main() {
	l, err := net.listen("tcp", ":4044")
	if err != nil {
		panic(err)
	}
	fmt.println("listen to 4044")
	for {
  // 监听到新的连接，创建新的 goroutine 交给 handleconn函数 处理
		conn, err := l.accept()
		if err != nil {
			fmt.println("conn err:", err)
		} else {
			go handleconn(conn)
		}
	}
}

func handleconn(conn net.conn) {
	defer conn.close()
	defer fmt.println("关闭")
	fmt.println("新连接：", conn.remoteaddr())

	result := bytes.newbuffer(nil)
	var buf [1024]byte
	for {
		n, err := conn.read(buf[0:])
		result.write(buf[0:n])
		if err != nil {
			if err == io.eof {
				continue
			} else {
				fmt.println("read err:", err)
				break
			}
		} else {
			fmt.println("recv:", result.string())
		}
		result.reset()
	}
}

客户端代码 client/main.go

func main() {
	data := []byte("[这里才是一个完整的数据包]")
	conn, err := net.dialtimeout("tcp", "localhost:4044", time.second*30)
	if err != nil {
		fmt.printf("connect failed, err : %v\n", err.error())
  return
	}
	for i := 0; i <1000; i++ {
		_, err = conn.write(data)
		if err != nil {
			fmt.printf("write failed , err : %v\n", err)
			break
		}
	}
}

运行结果

listen to 4044
新连接： [::1]:53079
recv: [这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据�
recv: �][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包]
recv: [这里才是一个完整的数据包]
recv: [这里才是一个完整的数据包]
recv: [这里才是一个完整的数据包][这里才是一个完整的数据包][这里才是一个完整的数据包]
recv: [这里才是一个完整的数据包]
...省略其它的...

从服务端的控制台输出可以看出，存在三种类型的输出：

一种是正常的一个数据包输出。
一种是多个数据包“粘”在了一起，我们定义这种读到的包为粘包。
一种是一个数据包被“拆”开，形成一个破碎的包，我们定义这种包为半包。

为什么会出现半包和粘包？

客户端一段时间内发送包的速度太多，服务端没有全部处理完。于是数据就会积压起来，产生粘包。
定义的读的buffer不够大，而数据包太大或者由于粘包产生，服务端不能一次全部读完，产生半包。

什么时候需要考虑处理半包和粘包？

tcp连接是长连接，即一次连接多次发送数据。
每次发送的数据是结构的，比如 json格式的数据或者数据包的协议是由我们自己定义的（包头部包含实际数据长度、协议魔数等）。

解决思路

定长分隔(每个数据包最大为该长度，不足时使用特殊字符填充) ，但是数据不足时会浪费传输资源
使用特定字符来分割数据包，但是若数据中含有分割字符则会出现bug
在数据包中添加长度字段，弥补了以上两种思路的不足，推荐使用

拆包演示

通过上述分析，我们最好通过第三种思路来解决拆包粘包问题。

golang的bufio库中有为我们提供了scanner，来解决这类分割数据的问题。

type scanner
scanner provides a convenient interface for reading data such as a file of newline-delimited lines of text. successive calls to the scan method will step through the 'tokens' of a file, skipping the bytes between the tokens. the specification of a token is defined by a split function of type splitfunc; the default split function breaks the input into lines with line termination stripped. split functions are defined in this package for scanning a file into lines, bytes, utf-8-encoded runes, and space-delimited words. the client may instead provide a custom split function.

简单来讲即是：

scanner为读取数据提供了方便的接口。连续调用scan方法会逐个得到文件的“tokens”，跳过 tokens 之间的字节。token 的规范由 splitfunc 类型的函数定义。我们可以改为提供自定义拆分功能。

接下来看看 splitfunc 类型的函数是什么样子的：

type splitfunc func(data []byte, ateof bool) (advance int, token []byte, err error)

golang官网文档上提供的使用例子????：

func main() {
	// an artificial input source.
	const input = "1234 5678 1234567901234567890"
	scanner := bufio.newscanner(strings.newreader(input))
	// create a custom split function by wrapping the existing scanwords function.
	split := func(data []byte, ateof bool) (advance int, token []byte, err error) {
		advance, token, err = bufio.scanwords(data, ateof)
		if err == nil && token != nil {
			_, err = strconv.parseint(string(token), 10, 32)
		}
		return
	}
	// set the split function for the scanning operation.
	scanner.split(split)
	// validate the input
	for scanner.scan() {
		fmt.printf("%s\n", scanner.text())
	}

	if err := scanner.err(); err != nil {
		fmt.printf("invalid input: %s", err)
	}
}

于是，我们可以这样改写我们的程序：

服务端代码 server/main.go

func main() {
	l, err := net.listen("tcp", ":4044")
	if err != nil {
		panic(err)
	}
	fmt.println("listen to 4044")
	for {
		conn, err := l.accept()
		if err != nil {
			fmt.println("conn err:", err)
		} else {
			go handleconn2(conn)
		}
	}
}

func packetslitfunc(data []byte, ateof bool) (advance int, token []byte, err error) {
  // 检查 ateof 参数 和 数据包头部的四个字节是否 为 0x123456(我们定义的协议的魔数)
	if !ateof && len(data) > 6 && binary.bigendian.uint32(data[:4]) == 0x123456 {
		var l int16
    // 读出 数据包中 实际数据 的长度(大小为 0 ~ 2^16)
		binary.read(bytes.newreader(data[4:6]), binary.bigendian, &l)
		pl := int(l) + 6
		if pl <= len(data) {
			return pl, data[:pl], nil
		}
	}
	return
}

func handleconn2(conn net.conn) {
	defer conn.close()
	defer fmt.println("关闭")
	fmt.println("新连接：", conn.remoteaddr())
	result := bytes.newbuffer(nil)
  var buf [65542]byte // 由于 标识数据包长度 的只有两个字节 故数据包最大为 2^16+4(魔数)+2(长度标识)
	for {
		n, err := conn.read(buf[0:])
		result.write(buf[0:n])
		if err != nil {
			if err == io.eof {
				continue
			} else {
				fmt.println("read err:", err)
				break
			}
		} else {
			scanner := bufio.newscanner(result)
			scanner.split(packetslitfunc)
			for scanner.scan() {
				fmt.println("recv:", string(scanner.bytes()[6:]))
			}
		}
		result.reset()
	}
}

客户端代码 client/main.go

func main() {
	l, err := net.listen("tcp", ":4044")
	if err != nil {
		panic(err)
	}
	fmt.println("listen to 4044")
	for {
		conn, err := l.accept()
		if err != nil {
			fmt.println("conn err:", err)
		} else {
			go handleconn2(conn)
		}
	}
}

func packetslitfunc(data []byte, ateof bool) (advance int, token []byte, err error) {
  // 检查 ateof 参数 和 数据包头部的四个字节是否 为 0x123456(我们定义的协议的魔数)
	if !ateof && len(data) > 6 && binary.bigendian.uint32(data[:4]) == 0x123456 {
		var l int16
    // 读出 数据包中 实际数据 的长度(大小为 0 ~ 2^16)
		binary.read(bytes.newreader(data[4:6]), binary.bigendian, &l)
		pl := int(l) + 6
		if pl <= len(data) {
			return pl, data[:pl], nil
		}
	}
	return
}

func handleconn2(conn net.conn) {
	defer conn.close()
	defer fmt.println("关闭")
	fmt.println("新连接：", conn.remoteaddr())
	result := bytes.newbuffer(nil)
  var buf [65542]byte // 由于 标识数据包长度 的只有两个字节 故数据包最大为 2^16+4(魔数)+2(长度标识)
	for {
		n, err := conn.read(buf[0:])
		result.write(buf[0:n])
		if err != nil {
			if err == io.eof {
				continue
			} else {
				fmt.println("read err:", err)
				break
			}
		} else {
			scanner := bufio.newscanner(result)
			scanner.split(packetslitfunc)
			for scanner.scan() {
				fmt.println("recv:", string(scanner.bytes()[6:]))
			}
		}
		result.reset()
	}
}

运行结果

listen to 4044
新连接： [::1]:55738
recv: [这里才是一个完整的数据包]
recv: [这里才是一个完整的数据包]
recv: [这里才是一个完整的数据包]
recv: [这里才是一个完整的数据包]
recv: [这里才是一个完整的数据包]
recv: [这里才是一个完整的数据包]
recv: [这里才是一个完整的数据包]
recv: [这里才是一个完整的数据包]
...省略其它的...

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对的支持。

上一篇： Vue实现购物车详情页面的方法

下一篇： Photoshop 一颗梦幻的云彩心

Golang TCP粘包拆包问题的解决方法

第二十八天- tcp下的粘包和解决方案

详解python中TCP协议中的粘包问题

Netty解决粘包和拆包问题的四种方案

6行代码快速解决golang TCP粘包问题

Golang TCP粘包拆包问题的解决方法

golang网络socket粘包问题的解决方法

NIO解决粘包问题的代码具体实现以及详细注释

网络编程协议(TCP和UDP协议,粘包问题)

荐 netty之TCP粘包拆包问题解决

模拟ssh远程执行命令,粘包问题,基于socketserver实现并发的socket