Golang心跳包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

package main

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

func main() {
	server := ":7373"
	netListen, err := net.Listen("tcp", server)
	if err != nil{
		LogC("connect error: ", err)
		os.Exit(1)
	}
	LogC("Waiting for Client ...")
	for{
		conn, err := netListen.Accept()
		if err != nil{
			LogC(conn.RemoteAddr().String(), "Fatal error: ", err)
			continue
		}

		//设置短连接(10秒)
		conn.SetReadDeadline(time.Now().Add(time.Duration(7)*time.Second))

		go handleConnection(conn)

	}
}

func handleConnection(conn net.Conn) {
	defer conn.Close()

	buffer := make([]byte, 1024)
	for {
		n, err := conn.Read(buffer)
		if err != nil {
			fmt.Println("server read err:",err)
			return
		}

		Data := buffer[:n]
		message := make(chan byte)
		//心跳计时
		go HeartBeating(conn, message, 9)
		//检测每次是否有数据传入
		go GravelChannel(Data, message)
	}
}
func GravelChannel(bytes []byte, message chan byte) {
	for _, v := range bytes{
		message <- v
	}
	close(message)
}
func HeartBeating(conn net.Conn, message chan byte, timeout int) {
	select {
	case fk := <- message:
		fmt.Println("心跳包:",string(fk))
		conn.SetDeadline(time.Now().Add(time.Duration(timeout) * time.Second))
		break

	case <- time.After(5 * time.Second):
		LogC("conn dead now")
		conn.Close()
	}
}
func LogC(v ...interface{}) {
	fmt.Println(v...)
	return
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
package main

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

func main() {
	server := "127.0.0.1:7373"

	tcpAddr, err := net.ResolveTCPAddr("tcp4",server)
	if err != nil{
		Log(os.Stderr,"Fatal error:",err.Error())
		os.Exit(1)
	}
	conn, err := net.DialTCP("tcp",nil,tcpAddr)
	if err != nil{
		Log("Fatal error:",err.Error())
		os.Exit(1)
	}
	Log(conn.RemoteAddr().String(), "connection succcess!")

	go func() {
		i := 0
		for  {
			fmt.Println(i)
			time.Sleep(time.Second)
			i++
		}
	}()

	time.Sleep(time.Second * 100)

	//sender(conn)
	Log("send over")

}
func sender(conn *net.TCPConn) {
	defer func() {
		fmt.Println("client close")
		conn.Close()
	}()

	for i := 0; i < 4; i++{
		_, err := conn.Write([]byte("p"))
		if err != nil {
			fmt.Println("client write err")
			return
		}
		fmt.Println("conn write success")
		time.Sleep(2 * time.Second)
	}
	for i := 0; i < 2 ; i++ {
		_, err := conn.Write([]byte("p"))
		if err != nil {
			fmt.Println("client write err")
			return
		}
		fmt.Println("conn write success")
		time.Sleep(8 * time.Second)
	}
	for i := 0; i < 3; i++{
		_, err := conn.Write([]byte("p"))
		if err != nil {
			fmt.Println("client write err")
			return
		}
		fmt.Println("conn write success")
		time.Sleep(2 * time.Second)
	}

}
func Log(v ...interface{}) {
	fmt.Println(v...)
	return
}