如题所述
一、socket 通信粘包的处理方法：
1、对于发送方引起的粘包现象，用户可通过编程设置来避免，TCP提供了强制数据立即传送的操作指令push，TCP软件收到该操作指令后，就立即将本段数据发送出去，而不必等待发送缓冲区满；
2、对于接收方引起的粘包，则可通过优化程序设计、精简接收进程工作量、提高接收进程优先级等措施，使其及时接收数据，从而尽量避免出现粘包现象；
3、由接收方控制，将一包数据按结构字段，人为控制分多次接收，然后合并，通过这种手段来避免粘包。
二、实现代码：
三、方法注意事项：
1、第一种编程设置方法虽然可以避免发送方引起的粘包，但它关闭了优化算法，降低了网络发送效率，影响应用程序的性能，一般不建议使用。
2、第二种方法只能减少出现粘包的可能性，但并不能完全避免粘包，当发送频率较高时，或由于网络突发可能使某个时间段数据包到达接收方较快，接收方还是有可能来不及接收，从而导致粘包；
3、第三种方法虽然避免了粘包，但应用程序的效率较低，对实时应用的场合不适合。
四、实验环境
1、硬件环境：服务器：pentium 350 微机 、客户机：pentium 166微机、网络平台：由10兆共享式hub连接而成的局域网；
2、软件环境：操作系统：windows 98 、编程语言：visual c++ 5.0
温馨提示：答案为网友推荐，仅供参考
第1个回答 2016-09-27
在用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，如果发现有问题可以联系我。
粘包示例server.go
//粘包问题演示服务端
package main
import (
"fmt"
"net"
"os"
)
func main() {
netListen, err := net.Listen("tcp", ":9988")
CheckError(err)
defer netListen.Close()
Log("Waiting for clients")
for {
conn, err := netListen.Accept()
if err != nil {
continue
}
Log(conn.RemoteAddr().String(), " tcp connect success")
go handleConnection(conn)
}
}
func handleConnection(conn net.Conn) {
buffer := make([]byte, 1024)
for {
n, err := conn.Read(buffer)
if err != nil {
Log(conn.RemoteAddr().String(), " connection error: ", err)
return
}
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)
}
}
复制代码
client.go
//粘包问题演示客户端
package main
import (
"fmt"
"net"
"os"
"time"
)
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)
for {
time.Sleep(1 * 1e9)
}
}
复制代码
运行后查看服务端输出：
可以看到json格式的字符串都粘到一起了，有种淡淡的忧伤了——头疼的事情又来了。
粘包产生原因
关于粘包的产生原因网上有很多相关的说明，主要原因就是tcp数据传递模式是流模式，在保持长连接的时候可以进行多次的收和发。如果要深入了解可以看看tcp协议方面的内容。这里推荐下鸟哥的私房菜，讲的非常通俗易懂。
粘包解决办法
主要有两种方法：
1、客户端发送一次就断开连接，需要发送数据的时候再次连接，典型如http。下面用golang演示一下这个过程，确实不会出现粘包问题。
//客户端代码，演示了发送一次数据就断开连接的
package main
import (
"fmt"
"net"
"os"
"time"
)
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()
}
for {
time.Sleep(1 * 1e9)
}
}
复制代码
服务端代码参考上面演示粘包产生过程的服务端代码
2、包头+数据的格式，根据包头信息读取到需要分析的数据。形式如下图：
golang粘包问题包头定义
从数据流中读取数据的时候，只要根据包头和数据长度就能取到需要的数据。这个其实就是平时说的协议（protocol），只是这个数据传输协议非常简单，不像tcp、ip等协议有较多的定义。在实际的过程中通常会定义协议类或者协议文件来封装封包和解包的过程。下面代码演示了封包和解包的过程：
protocol.go
//通讯协议处理，主要处理封包和解包的过程
package protocol
import (
"bytes"
"encoding/binary"
)
const (
ConstHeader = ""
ConstHeaderLength = 15
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)
var i int
for i = 0; i < length; i = i + 1 {
if length < i+ConstHeaderLength+ConstSaveDataLength {
break
}
if string(buffer[i:i+ConstHeaderLength]) == ConstHeader {
messageLength := BytesToInt(buffer[i+ConstHeaderLength : i+ConstHeaderLength+ConstSaveDataLength])
if length < i+ConstHeaderLength+ConstSaveDataLength+messageLength {
break
}
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：解包的过程中要注意数组越界的问题；另外包头要注意唯一性。
server.go
//服务端解包过程
package main
import (
"./protocol"
"fmt"
"net"
"os"
)
func main() {
netListen, err := net.Listen("tcp", ":9988")
CheckError(err)
defer netListen.Close()
Log("Waiting for clients")
for {
conn, err := netListen.Accept()
if err != nil {
continue
}
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)
for {
n, err := conn.Read(buffer)
if err != nil {
Log(conn.RemoteAddr().String(), " connection error: ", err)
return
}
tmpBuffer = protocol.Unpack(append(tmpBuffer, buffer[:n]...), readerChannel)
}
}
func reader(readerChannel chan []byte) {
for {
select {
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)
}
}
复制代码
client.go
//客户端发送封包
package main
import (
"./protocol"
"fmt"
"net"
"os"
"time"
)
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)
for {
time.Sleep(1 * 1e9)
}
}
复制代码
最后
上面演示的两种方法适用于不同的场景。第一种方法比较适合被动型的场景，例如打开网页，用户有请求才处理交互。第二种方法适合于主动推送的类型，例如即时聊天系统，因为要即时给用户推送消息，保持长连接是不可避免的，这时候就要用这种方法。
{"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，如果发现有问题可以联系我。
粘包示例server.go
//粘包问题演示服务端
package main
import (
"fmt"
"net"
"os"
)
func main() {
netListen, err := net.Listen("tcp", ":9988")
CheckError(err)
defer netListen.Close()
Log("Waiting for clients")
for {
conn, err := netListen.Accept()
if err != nil {
continue
}
Log(conn.RemoteAddr().String(), " tcp connect success")
go handleConnection(conn)
}
}
func handleConnection(conn net.Conn) {
buffer := make([]byte, 1024)
for {
n, err := conn.Read(buffer)
if err != nil {
Log(conn.RemoteAddr().String(), " connection error: ", err)
return
}
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)
}
}
复制代码
client.go
//粘包问题演示客户端
package main
import (
"fmt"
"net"
"os"
"time"
)
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)
for {
time.Sleep(1 * 1e9)
}
}
复制代码
运行后查看服务端输出：
可以看到json格式的字符串都粘到一起了，有种淡淡的忧伤了——头疼的事情又来了。
粘包产生原因
关于粘包的产生原因网上有很多相关的说明，主要原因就是tcp数据传递模式是流模式，在保持长连接的时候可以进行多次的收和发。如果要深入了解可以看看tcp协议方面的内容。这里推荐下鸟哥的私房菜，讲的非常通俗易懂。
粘包解决办法
主要有两种方法：
1、客户端发送一次就断开连接，需要发送数据的时候再次连接，典型如http。下面用golang演示一下这个过程，确实不会出现粘包问题。
//客户端代码，演示了发送一次数据就断开连接的
package main
import (
"fmt"
"net"
"os"
"time"
)
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()
}
for {
time.Sleep(1 * 1e9)
}
}
复制代码
服务端代码参考上面演示粘包产生过程的服务端代码
2、包头+数据的格式，根据包头信息读取到需要分析的数据。形式如下图：
golang粘包问题包头定义
从数据流中读取数据的时候，只要根据包头和数据长度就能取到需要的数据。这个其实就是平时说的协议（protocol），只是这个数据传输协议非常简单，不像tcp、ip等协议有较多的定义。在实际的过程中通常会定义协议类或者协议文件来封装封包和解包的过程。下面代码演示了封包和解包的过程：
protocol.go
//通讯协议处理，主要处理封包和解包的过程
package protocol
import (
"bytes"
"encoding/binary"
)
const (
ConstHeader = ""
ConstHeaderLength = 15
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)
var i int
for i = 0; i < length; i = i + 1 {
if length < i+ConstHeaderLength+ConstSaveDataLength {
break
}
if string(buffer[i:i+ConstHeaderLength]) == ConstHeader {
messageLength := BytesToInt(buffer[i+ConstHeaderLength : i+ConstHeaderLength+ConstSaveDataLength])
if length < i+ConstHeaderLength+ConstSaveDataLength+messageLength {
break
}
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：解包的过程中要注意数组越界的问题；另外包头要注意唯一性。
server.go
//服务端解包过程
package main
import (
"./protocol"
"fmt"
"net"
"os"
)
func main() {
netListen, err := net.Listen("tcp", ":9988")
CheckError(err)
defer netListen.Close()
Log("Waiting for clients")
for {
conn, err := netListen.Accept()
if err != nil {
continue
}
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)
for {
n, err := conn.Read(buffer)
if err != nil {
Log(conn.RemoteAddr().String(), " connection error: ", err)
return
}
tmpBuffer = protocol.Unpack(append(tmpBuffer, buffer[:n]...), readerChannel)
}
}
func reader(readerChannel chan []byte) {
for {
select {
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)
}
}
复制代码
client.go
//客户端发送封包
package main
import (
"./protocol"
"fmt"
"net"
"os"
"time"
)
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)
for {
time.Sleep(1 * 1e9)
}
}
复制代码
最后
上面演示的两种方法适用于不同的场景。第一种方法比较适合被动型的场景，例如打开网页，用户有请求才处理交互。第二种方法适合于主动推送的类型，例如即时聊天系统，因为要即时给用户推送消息，保持长连接是不可避免的，这时候就要用这种方法。
