1. TCP黏包

    服务端代码如下：

    客户端代码如下：

    3. func main() {
    4.     conn, err := net.Dial("tcp", "127.0.0.1:30000")
    5.     if err != nil {
    6.         fmt.Println("dial failed, err", err)
    7.         return
    8.     }
    9.     defer conn.Close()
    10.     for i := 0; i < 20; i++ {
    11.         msg := `Hello, Hello. How are you?`
    12.         conn.Write([]byte(msg))
    13.     }
    14. }

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

    主要原因就是tcp数据传递模式是流模式，在保持长连接的时候可以进行多次的收和发。

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

    1.     1.由Nagle算法造成的发送端的粘包：Nagle算法是一种改善网络传输效率的算法。简单来说就是当我们提交一段数据给TCP发送时，TCP并不立刻发送此段数据，而是等待一小段时间看看在等待期间是否还有要发送的数据，若有则会一次把这两段数据发送出去。

    1.1.2. 解决办法

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

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

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

    服务端代码如下：

    1. // socket_stick/server2/main.go
    3. func process(conn net.Conn) {
    4.     defer conn.Close()
    5.     reader := bufio.NewReader(conn)
    6.     for {
    7.         msg, err := proto.Decode(reader)
    8.         if err == io.EOF {
    9.             return
    10.         }
    11.         if err != nil {
    12.             fmt.Println("decode msg failed, err:", err)
    13.             return
    14.         }
    15.         fmt.Println("收到client发来的数据：", msg)
    16.     }
    17. }
    20.     listen, err := net.Listen("tcp", "127.0.0.1:30000")
    21.     if err != nil {
    22.         fmt.Println("listen failed, err:", err)
    23.         return
    24.     }
    25.     defer listen.Close()
    26.     for {
    27.         conn, err := listen.Accept()
    28.         if err != nil {
    29.             fmt.Println("accept failed, err:", err)
    30.             continue
    31.         }
    32.         go process(conn)
    33.     }
    34. }