go | 过墙梯官方博客你的位置： >
> golang中tcp socket粘包问题和处理
在用golang开发人工客服系统的时候碰到了粘包问题，那么什么是粘包呢？例如我们和客户端约定数据交互格式是一个json格式的字符串：
{"Id":1,"Name":"golang","Message":"message"}
当客户端发送数据给服务端的时候，如果服务端没有及时接收，客户端又发送了一条数据上来，这时候服务端才进行接收的话就会收到两个连续的字符串，形如：
{"Id":1,"Name":"golang","Message":"message"}{"Id":1,"Name":"golang","Message":"message"}
如果接收缓冲区满了的话，那么也有可能接收到半截的json字符串，酱紫的话还怎么用json解码呢？真是头疼。以下用golang模拟了下这个粘包的产生。
备注：下面贴的代码均可以运行于golang 1.3.1，如果发现有问题可以联系我。
//粘包问题演示服务端
package main
func main() {
netListen, err := net.Listen(&tcp&, &:9988&)
CheckError(err)
defer netListen.Close()
Log(&Waiting for clients&)
conn, err := netListen.Accept()
if err != nil {
Log(conn.RemoteAddr().String(), & tcp connect success&)
go handleConnection(conn)
func handleConnection(conn net.Conn) {
buffer := make([]byte, 1024)
n, err := conn.Read(buffer)
if err != nil {
Log(conn.RemoteAddr().String(), & connection error: &, err)
Log(conn.RemoteAddr().String(), &receive data length:&, n)
Log(conn.RemoteAddr().String(), &receive data:&, buffer[:n])
Log(conn.RemoteAddr().String(), &receive data string:&, string(buffer[:n]))
func Log(v ...interface{}) {
fmt.Println(v...)
func CheckError(err error) {
if err != nil {
fmt.Fprintf(os.Stderr, &Fatal error: %s&, err.Error())
os.Exit(1)
//粘包问题演示客户端
package main
func sender(conn net.Conn) {
for i := 0; i & 100; i++ {
words := &{\&Id\&:1,\&Name\&:\&golang\&,\&Message\&:\&message\&}&
conn.Write([]byte(words))
func main() {
server := &127.0.0.1:9988&
tcpAddr, err := net.ResolveTCPAddr(&tcp4&, server)
if err != nil {
fmt.Fprintf(os.Stderr, &Fatal error: %s&, err.Error())
os.Exit(1)
conn, err := net.DialTCP(&tcp&, nil, tcpAddr)
if err != nil {
fmt.Fprintf(os.Stderr, &Fatal error: %s&, err.Error())
os.Exit(1)
defer conn.Close()
fmt.Println(&connect success&)
go sender(conn)
time.Sleep(1 * 1e9)
运行后查看服务端输出：
golang粘包问题演示
可以看到json格式的字符串都粘到一起了，有种淡淡的忧伤了——头疼的事情又来了。
粘包产生原因
关于粘包的产生原因网上有很多相关的说明，主要原因就是tcp数据传递模式是流模式，在保持长连接的时候可以进行多次的收和发。如果要深入了解可以看看tcp协议方面的内容。这里推荐下鸟哥的私房菜，讲的非常通俗易懂。
粘包解决办法
主要有两种方法：
1、客户端发送一次就断开连接，需要发送数据的时候再次连接，典型如http。下面用golang演示一下这个过程，确实不会出现粘包问题。
//客户端代码，演示了发送一次数据就断开连接的
package main
func main() {
server := &127.0.0.1:9988&
for i := 0; i & 10000; i++ {
tcpAddr, err := net.ResolveTCPAddr(&tcp4&, server)
if err != nil {
fmt.Fprintf(os.Stderr, &Fatal error: %s&, err.Error())
os.Exit(1)
conn, err := net.DialTCP(&tcp&, nil, tcpAddr)
if err != nil {
fmt.Fprintf(os.Stderr, &Fatal error: %s&, err.Error())
os.Exit(1)
words := &{\&Id\&:1,\&Name\&:\&golang\&,\&Message\&:\&message\&}&
conn.Write([]byte(words))
conn.Close()
time.Sleep(1 * 1e9)
服务端代码参考上面演示粘包产生过程的服务端代码
2、包头+数据的格式，根据包头信息读取到需要分析的数据。形式如下图：
golang粘包问题包头定义
从数据流中读取数据的时候，只要根据包头和数据长度就能取到需要的数据。这个其实就是平时说的协议（protocol），只是这个数据传输协议非常简单，不像tcp、ip等协议有较多的定义。在实际的过程中通常会定义协议类或者协议文件来封装封包和解包的过程。下面代码演示了封包和解包的过程：
protocol.go
//通讯协议处理，主要处理封包和解包的过程
package protocol
&encoding/binary&
ConstHeader
ConstHeaderLength
ConstSaveDataLength = 4
func Packet(message []byte) []byte {
return append(append([]byte(ConstHeader), IntToBytes(len(message))...), message...)
func Unpack(buffer []byte, readerChannel chan []byte) []byte {
length := len(buffer)
for i = 0; i & i = i + 1 {
if length & i+ConstHeaderLength+ConstSaveDataLength {
if string(buffer[i:i+ConstHeaderLength]) == ConstHeader {
messageLength := BytesToInt(buffer[i+ConstHeaderLength : i+ConstHeaderLength+ConstSaveDataLength])
if length & i+ConstHeaderLength+ConstSaveDataLength+messageLength {
data := buffer[i+ConstHeaderLength+ConstSaveDataLength : i+ConstHeaderLength+ConstSaveDataLength+messageLength]
readerChannel &- data
i += ConstHeaderLength + ConstSaveDataLength + messageLength - 1
if i == length {
return make([]byte, 0)
return buffer[i:]
//整形转换成字节
func IntToBytes(n int) []byte {
x := int32(n)
bytesBuffer := bytes.NewBuffer([]byte{})
binary.Write(bytesBuffer, binary.BigEndian, x)
return bytesBuffer.Bytes()
//字节转换成整形
func BytesToInt(b []byte) int {
bytesBuffer := bytes.NewBuffer(b)
var x int32
binary.Read(bytesBuffer, binary.BigEndian, &x)
return int(x)
tips：解包的过程中要注意数组越界的问题；另外包头要注意唯一性。
//服务端解包过程
package main
&./protocol&
func main() {
netListen, err := net.Listen(&tcp&, &:9988&)
CheckError(err)
defer netListen.Close()
Log(&Waiting for clients&)
conn, err := netListen.Accept()
if err != nil {
Log(conn.RemoteAddr().String(), & tcp connect success&)
go handleConnection(conn)
func handleConnection(conn net.Conn) {
//声明一个临时缓冲区，用来存储被截断的数据
tmpBuffer := make([]byte, 0)
//声明一个管道用于接收解包的数据
readerChannel := make(chan []byte, 16)
go reader(readerChannel)
buffer := make([]byte, 1024)
n, err := conn.Read(buffer)
if err != nil {
Log(conn.RemoteAddr().String(), & connection error: &, err)
tmpBuffer = protocol.Unpack(append(tmpBuffer, buffer[:n]...), readerChannel)
func reader(readerChannel chan []byte) {
case data := &-readerChannel:
Log(string(data))
func Log(v ...interface{}) {
fmt.Println(v...)
func CheckError(err error) {
if err != nil {
fmt.Fprintf(os.Stderr, &Fatal error: %s&, err.Error())
os.Exit(1)
//客户端发送封包
package main
&./protocol&
func sender(conn net.Conn) {
for i := 0; i & 1000; i++ {
words := &{\&Id\&:1,\&Name\&:\&golang\&,\&Message\&:\&message\&}&
conn.Write(protocol.Packet([]byte(words)))
fmt.Println(&send over&)
func main() {
server := &127.0.0.1:9988&
tcpAddr, err := net.ResolveTCPAddr(&tcp4&, server)
if err != nil {
fmt.Fprintf(os.Stderr, &Fatal error: %s&, err.Error())
os.Exit(1)
conn, err := net.DialTCP(&tcp&, nil, tcpAddr)
if err != nil {
fmt.Fprintf(os.Stderr, &Fatal error: %s&, err.Error())
os.Exit(1)
defer conn.Close()
fmt.Println(&connect success&)
go sender(conn)
time.Sleep(1 * 1e9)
运行这个程序可以看到服务端很好的获取到期望的json格式数据。完整代码演示下载：
上面演示的两种方法适用于不同的场景。第一种方法比较适合被动型的场景，例如打开网页，用户有请求才处理交互。第二种方法适合于主动推送的类型，例如即时聊天系统，因为要即时给用户推送消息，保持长连接是不可避免的，这时候就要用这种方法。
转载请注明： &
与本文相关的文章7867人阅读
golang（11）
package main
&encoding/base64&
base64Table = &123QRSTUabcdVWXYZHijKLAWDCABDstEFGuvwxyzGHIJklmnopqr&
var coder = base64.NewEncoding(base64Table)
func base64Encode(src []byte) []byte {
return []byte(coder.EncodeToString(src))
func base64Decode(src []byte) ([]byte, error) {
return coder.DecodeString(string(src))
func main() {
hello := &hello world&
debyte := base64Encode([]byte(hello))
enbyte, err := base64Decode(debyte)
if err != nil {
fmt.Println(err.Error())
if hello != string(enbyte) {
fmt.Println(&hello is not equal to enbyte&)
fmt.Println(string(enbyte))
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：136871次
积分：1171
积分：1171
排名：千里之外
原创：11篇
评论：29条
(1)(10)(1)(1)(2)(2)go的byte跟string有什么区别_百度知道
go的byte跟string有什么区别
byte是字节型数据，string是字符串型数据，它们的数据类型不同。一、字符串型。字符串型的变量，字符码范围为0到255，可以声明变长和定长字符串。用“String*大小”的语法声明一个定长字符串。在Visual Basic中，文字字符串要用引号引起来。二、字节型。变量包含二进制数时，使用字节型。在转换格式期间，最好用字节型变量存储二进制数。§除了一元减法外，可以对整数进行处理的运算符均可处理字节型的数据类型。因为字节型是从0到255的无符号类型，所以不能表示负数。
其他类似问题
为您推荐：
提问者采纳
数据go是前往，string是字符串。去，字符，byte是8位无符号整数
string的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁　　一如既往，继续Go语言的学习，不过继续学习之前，容许我再废话几句。最近发现坚持一件事情很重要，而且最近也发现坚持一件事情真的有点难。虽然文章基础，不过我还是要坚持的，废话完毕，那么就继续吧。
一 Go语言之字符串
　　与大多数面向对象编程语言一样，Go语言也具有string（字符串）类型，只不过它与其它语言例如java中的String类型不一样的是它是值类型。并且注意声明的关键字是string，全部小写的哦，亲（java程序员尤其注意，c#程序员偷乐中......）。除此之外，它还有个特性就是不可变性，这里需要注意的是指字符串本身不可变并不是字符串变量不可变，稍后看例子就能明白。在Go语言中string类型的结构如下：
1 struct String
上述结构可以在Go语言的源代码中的runtime.h头文件中找到。从上述结构，我们可以看出，其实string类型是由一个byte指针和int32类型的表示字符串长度的变量两部分组成。其中这里的byte是uint8的别名，实质上它就表示8位的无符号整数，因此本质上在计算机上字符串其实也就是数字而已。只不过，通过不同的编码方式将数字映射到相应的字符上。而且在Go语言中使用的是UTF-8编码方式。如果你还不明白所谓的编码方式，那么请自己通过网络查阅吧，因为涉及的知识点又会比较多，而今天我们只关注Go语言，所以这里就不细说了。
以上结构是Go语言的runtime中的c语言的结构体，所以，实际上在Go语言中的string类型你可以理解成内部就是上面的结构，至于是如何实现的，现在没必要搞清楚，这关乎Go的语言底层实现了，暂时我们只需要使用就可以了。当然有兴趣的也可以从底层去挖。
为了让事情更好玩些，我们当然也可以在Go语言层面上模拟下上面的结构，当然实际中是毫无意义的，看下面：
在main函数中首先声明定义了一个animal的字符串，然后将它转成byte数组，并将它的地址传给我们自定义的String结构体，但是String结构体的第一个参数不是一个指针类型吗？没错，其实指针变量就是用来存放该类型的内存地址的变量，当它接收一个byte数组的首地址时，就可以控制数组了。所以，当我们传递给String结构体前面的那个b的byte数组的地址后，其实也就可以控制这个数组了。是不是已经晕了？嘿嘿，正常，当初刚学C语言的时候，笔者也一直没明白指针。后来慢慢的就习惯了。再看上图30行，这的print是我们自己定义的打印这个结构体的函数，当我们传入String结构体类型cat变量后，第16行，我们循环遍历结构体的指针变量，打印出它的每一个byte，由于Go语言不能和C语言一样直接进行指针运算，所以需要引入unsafe包，通过它进行运算，这里就不详细介绍了，如非需要了解可以查询文档，不过对于初学者来说没什么大的意义，而且Go本来就不建议直接指针运算，不然直接用C好了，嘿嘿。通过上面的一顿折腾，最终将byte转成string打印出来，所以最后byte数组又被还原成string了。
看完上面一段，估计有读者要骂了，Go语言那么麻烦，比C语言还麻烦。请冷静啊，上面的在实际开发中是几乎很少用到的，不然还真不如直接用C语言了，我这里写这一大堆，只是想阐释下它的内部结构，顺带练习下Go的结构体，完全没明白的也不用管，或许等随着我们的深入学习，时间久了，再回来看就能明白了哦。
二 字符串操作
　　了解了字符串的基本情况后，我们再来看看对于字符串的操作。在上一节中，我们其实已经对字符串求了它的长度，就是通过len函数。不过它求得的结果并不是字符串中字符的个数，这似乎和其它一些的语言不太一样，例如java。不过，当你赋值给它的都是英文字符的时候，似乎这个结果就是字符个数，但是当你将中文赋值给它后，就有些不太对了，不信可以试试。这里我将开发平台切换到了Linux，因为在windows下命令提示符下对于UTF-8的字符集操作不太方便。请看例子：
最终结果是：
结果是12，有图有真相，为什么是这个结果呢？原因是在Go语言中，字符是utf-8编码的，其中英文字符一个算一个字节，中文算三个字节。那么，我们如果非要得到字符个数呢？可以将string转换成[]rune类型：
rune没啥好奇怪的，其实就是int32的别名，所以这里其实是将string转成了32位整数数组分别存入对应字符的unicode，这样最终有几个字符就对应几个unicode分别位于数组中。因此最后可以得到长度为2。当然可以打印看下unicode是什么：
&接下来，来点轻松的，大家都知道python中对数组可以切片，在Go中，也可以。如下：
最终结果：
&今天就到这里，感觉文章越来越长了，额，没办法，随着深入学习必然会这样，但是我还是会尽量缩短每篇的长度的。希望对大家有帮助~
阅读(...) 评论()