golang网络库中tcp的几种报错

package main

import (
	"fmt"
	"net"
	"time"
)

func Serve() {
	l, err := net.Listen("tcp", ":8888")
	if err != nil {
		fmt.Println("err:", err.Error())
	}
	fmt.Println("listen ok")
	for {
		conn, err := l.Accept()
		fmt.Println("accept new conn")
		if err != nil {
			fmt.Println("accept err:", err.Error())
			return
		}
		go ProcessConn(conn)
	}
}
func ProcessConn(c net.Conn) {
	for {
		c.SetReadDeadline(time.Now().Add(5 * time.Second))
		buf := make([]byte, 1025)
		_, err := c.Read(buf)
		if err != nil {
			fmt.Println("read err:", err.Error())
			return
		}
		fmt.Println("buf:", string(buf))
	}
}

func ProcessConnReDDL(c net.Conn) {
	//设置的DDL超时以后，如果重新设置ddl，则新的ddl会覆盖老的，进行read的时候以新的ddl来判断是否超时
	c.SetReadDeadline(time.Now().Add(1 * time.Second))
	time.Sleep(2 * time.Second)
	for {
		c.SetReadDeadline(time.Now().Add(5 * time.Second))
		buf := make([]byte, 1025)
		_, err := c.Read(buf)
		if err != nil {
			fmt.Println("read err:", err.Error())
			return
		}
		fmt.Println("buf:", string(buf))
	}
}

func ProcessConnDDL(c net.Conn) {
	c.SetReadDeadline(time.Now().Add(1 * time.Second))
	for {
		//设置了read ddl以后，在对应时间内没read到数据，或者没进行read操作，则报错read tcp 127.0.0.1:8888->127.0.0.1:56600: i/o timeout
		c.SetReadDeadline(time.Now().Add(1 * time.Second))
		time.Sleep(3 * time.Second)
		buf := make([]byte, 1025)
		_, err := c.Read(buf)
		if err != nil {
			fmt.Println("read err:", err.Error())
			return
		}
		fmt.Println("buf:", string(buf))
	}
}

//设置完read ddl以后，只要在ddl内读到了，这个设置就失效了，即使后面sleep更长的时间，后面再读也不会报错
func ProcessConnWithDDl(c net.Conn) {
	for {
		c.SetReadDeadline(time.Now().Add(5 * time.Second))
		buf := make([]byte, 1025)
		_, err := c.Read(buf)
		fmt.Println("buf:", string(buf))
		if err != nil {
			fmt.Println("read err:", err.Error())
			return
		}
		time.Sleep(10 * time.Second)
	}
}

//正常关闭，客户端主动四次挥手
func Client() {
	dial, err := net.Dial("tcp", ":8888")
	if err != nil {
		fmt.Println("dial err:", err.Error())
		return
	}
	dial.Write([]byte("xxx"))
	dial.Close()
	fmt.Println("client close")
}

//客户端发送RST
func RSTClient() {
	dial, err := net.Dial("tcp", ":8888")
	if err != nil {
		fmt.Println("RST dial err:", err.Error())
		return
	}
	dial.Write([]byte("xxx"))
	time.Sleep(3 * time.Second)
	dial.(*net.TCPConn).SetLinger(0)
	dial.Close()
	fmt.Println("RST client close")
}

//客户端自己到DDL了，golang里面客户端ddl以后，不会四次挥手，也不会发RST。如果服务端不设置readddl，就永远不知道客户端断开了。TCP的KeepAlive默认是没开的，即使开，也太长了
func DDlClient() {
	dial, err := net.Dial("tcp", ":8888")
	if err != nil {
		fmt.Println("RST dial err:", err.Error())
		return
	}
	dial.Write([]byte("xxx"))
	dial.(*net.TCPConn).SetDeadline(time.Now().Add(1 * time.Second))
	time.Sleep(10 * time.Second)
	//dial.SetDeadline(time.Now().Add(3 * time.Second))
}

//客户端发了数据之后，长时间不动，服务端ddl到了以后，服务端报错read tcp 127.0.0.1:8888->127.0.0.1:56783: i/o timeout。这种情况对服务端来说和上种情况一样，只是客户端这里表现不一样
func SleepClient() {
	dial, err := net.Dial("tcp", ":8888")
	if err != nil {
		fmt.Println("RST dial err:", err.Error())
		return
	}
	dial.Write([]byte("xxx"))
	time.Sleep(30 * time.Second)
}

//每秒写一次
func WriteClient() {
	dial, err := net.Dial("tcp", ":8888")
	if err != nil {
		fmt.Println("RST dial err:", err.Error())
		return
	}
	for {
		dial.Write([]byte("xxx"))
		time.Sleep(3 * time.Second)
	}
}

//1.client向server发请求，如果server没有监听对应的端口，会报错 connection refused，底层server会给client发RST
//2.client写完数据以后正常调用close关闭【四次挥手】，server会读到EOF错误，客户端主动断连，客户端进入timewait
//3.client写完数据以后异常关闭【RST】，server报错如下： read tcp 127.0.0.1:8888->127.0.0.1:51136: read: connection reset by peer
//4.client写完数据以后，客户端不四次挥手，也不发心跳，server到达read ddl以后，报错： read tcp 127.0.0.1:8888->127.0.0.1:52595: i/o timeout
func main() {
	go Serve()
	time.Sleep(3 * time.Second)
	//go Client()
	//time.Sleep(3 * time.Second)
	//fmt.Println("==========RST")
	//go RSTClient()
	//time.Sleep(3 * time.Second)
	fmt.Println("==========DDl")
	go DDlClient()
	//fmt.Println("===========SLEEP")
	//go SleepClient()
	//fmt.Println("======WRITE")
	//go WriteClient()
	time.Sleep(30 * time.Second)
}