没事随便写个小东西,虽然不知道想做啥,先留着

package main

import (
	"bufio"
	"encoding/json"
	"fmt"
	"log"
	"net"
	"strings"
	"sync"
	"time"
)
import (
	"net/http"
	_ "net/http/pprof"
)

func cmain() {
	con, err := net.Dial("tcp", "127.0.0.1:1789")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer con.Close()
	lock := new(sync.Mutex)
	r := getBufPool(con)
	defer putBufPool(r)
	go func(con net.Conn, r *bufio.Reader, l *sync.Mutex) {
		for {
			time.Sleep(1e9)
			l.Lock()
			s := Msg{Action: "Test.Ping"}
			b, _ := json.Marshal(s)
			con.Write(b)
			con.Write([]byte("\r\n"))
			line, _, err := r.ReadLine()
			if err != nil {
				for i := 0; i < 3; i++ {
					con, err = net.Dial("tcp", "127.0.0.1:1789")
					if err != nil {
						fmt.Println("链接失败:", err)
						continue
					}
					break
				}
			}
			fmt.Println("这个是testPing:", string(line))
			l.Unlock()
		}
	}(con, r, lock)

	for {
		lock.Lock()
		s := Msg{Action: "scripts", Address: "127.0.0.1"}
		b, _ := json.Marshal(s)
		con.Write(b)
		con.Write([]byte("\r\n"))
		line, _, _ := r.ReadLine()
		switch string(line) {
		case "Already exist":
			fmt.Println(string(line))
			return
		}
		lock.Unlock()
		time.Sleep(3e9)
	}
}

func main() {
	go func() {
		log.Println(http.ListenAndServe("localhost:6060", nil))
	}()
	lis, err := net.Listen("tcp", "0.0.0.0:1789")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer lis.Close()
	for {
		con, err := lis.Accept()
		if err != nil {
			fmt.Println(err)
			continue
		}
		go Hander(con)
	}
}

type Msg struct {
	Action  string `json:action`
	Address string `json:address`
	JobID   int64  `json:jobid`
	Remark  string `json:remark`
}

var empty []byte

func Hander(con net.Conn) {
	defer con.Close()
	ip := strings.Split(con.RemoteAddr().String(), ":")[0]
	defer statusMap.Del(ip)
	if !statusMap.Add(ip) {
		fmt.Fprint(con, "Already exist\r\n")
		return
	}
	buf := getBufPool(con)
	defer putBufPool(buf)
	for {
		line, _, err := buf.ReadLine()
		if err != nil {
			return
		}
		msg, err := decode(line)
		if err != nil {
			fmt.Fprint(con, "Unknow type\r\n")
			putJsonPool(msg)
			continue
		}
		if b, err := handlerMsg(msg); err != nil {
			fmt.Fprint(con, "Can't execute this job.\r\n")
			putJsonPool(msg)
			continue
		} else {
			con.Write(b)
			con.Write([]byte{13, 10})
		}
		putJsonPool(msg)
	}
}

func handlerMsg(msg *Msg) ([]byte, error) {
	msg.JobID = NewID()
	b, err := encode(msg)
	if err != nil {
		return empty, err
	}
	fmt.Println("收到的消息:", *msg)
	handmsg(msg.Action, "127.0.0.1")
	fmt.Println(statusMap)
	//执行对应操作
	return b, nil
}

func handmsg(b string, ip string) {
	switch b {
	case "Test.Ping":
		statusMap[ip] = getNow()
	}
}

type statusM map[string]int64

var statusMap statusM = make(statusM)

func (statusM) Flush(ip string) {
	statusMap[ip] = getNow()
}

func (statusM) Del(ip string) {
	delete(statusMap, ip)
}

func (statusM) Add(ip string) bool {
	_, ok := statusMap[ip]
	if ok {
		return false
	}
	statusMap.Flush(ip)
	return true
}

var Pool sync.Pool

func getBufPool(con net.Conn) *bufio.Reader {
	buf := Pool.Get()
	if buf != nil {
		b := buf.(*bufio.Reader)
		b.Reset(con)
		return b
	}
	return bufio.NewReader(con)
}

func putBufPool(b *bufio.Reader) {
	b.Reset(nil)
	Pool.Put(b)
}

var GlobalLock sync.Mutex

func NewID() int64 {
	GlobalLock.Lock()
	defer GlobalLock.Unlock()
	time.Sleep(1e9)
	return getNow()
}

func getNow() int64 {
	return time.Now().Unix()
}

func decode(b []byte) (*Msg, error) {
	j := getJsonPool()
	fmt.Println("开始解析:", string(b))
	err := json.Unmarshal(b, j)
	if err != nil {
		return nil, err
	}
	return j, nil
}

func encode(msg *Msg) ([]byte, error) {
	return json.Marshal(*msg)
}

var JsonPool sync.Pool

func getJsonPool() *Msg {
	buf := Pool.Get()
	if buf != nil {
		b := buf.(*Msg)
		return b
	}
	return new(Msg)
}

func putJsonPool(m *Msg) {
	*m = Msg{}
	JsonPool.Put(m)
}