golang io使用及优化模式

func handleConn(c net.Conn) {
    defer c.Close()
    for {
        // read from the connection
        // ... ...
        // write to the connection
        //... ...
    }
}
func main() {
    l, err := net.Listen("tcp", ":8888")
    if err != nil {
        fmt.Println("listen error:", err)
        return
    }
    for {
        c, err := l.Accept()
        if err != nil {
            fmt.Println("accept error:", err)
            break
        }
        // start a new goroutine to handle
        // the new connection.
        go handleConn(c)
    }
}

type Packet interface {
    Decode(io.Reader)(Packet,error)    
    Encode(io.Writer,Packet) error 
}
func handleConn(c net.Conn) {
    defer c.Close()
	packet = new ...
    for {
        // read from the connection
        packet, err := Decode(c)
		ackPacket, err := handlePacket(packet)
        // write to the connection
        err := Encode(c,ackPacket)
    }
}

s := Submit{}
// 改为
var SubmitPool = sync.Pool{
    New: func() interface{} {
        return &Submit{}
    },
}
s := SubmitPool.Get().(*Submit) // 从SubmitPool池中获取一个Submit内存对象
...
SubmitPool.Put(submit)          // 将submit对象归还给Pool池

server := getty.NewTCPServer(options...)
server.RunEventLoop(newSession NewSessionCallback)
// type NewSessionCallback func(Session) error
// 用户需要通过该函数，为 session 设置好要用的 Reader、Writer 以及 EventListener。
func newSession(session getty.Session) error {
    ...
    session.SetPkgHandler(echoPkgHandler)       // 在 echoPkgHandler 中实现编解码
	session.SetEventListener(echoMsgHandler)    // 在onMessage 中实现业务逻辑
    ession.SetReadTimeout(conf.GettySessionParam.tcpReadTimeout)
	session.SetWriteTimeout(conf.GettySessionParam.tcpWriteTimeout)
    ...
}

// github.com/AlexStocks/getty/transport/server.go
func (s *server) RunEventLoop(newSession NewSessionCallback) {
    err := s.listen()	  			// ==> server.listenTCP ==> server.streamListener = net.Listen("tcp", server.addr) 开启监听
	switch s.endPointType {
	case TCP_SERVER:
		s.runTcpEventLoop(newSession)
    ...
	}
}
func (s *server) runTcpEventLoop(newSession NewSessionCallback) {
	s.wg.Add(1)
	go func() {
		defer s.wg.Done()
		for {
			client, err = s.accept(newSession) // conn = server.streamListener.Accept(); session := newTCPSession(conn, server)
			client.(*session).run()
		}
	}()
}
// github.com/AlexStocks/getty/transport/session.go
func (s *session) run() {
    err := s.listener.OnOpen(s)
	go s.handleLoop()           // 发送网络字节流、调用 EventListener.OnCron() 执行定时逻辑
	go s.handlePackage()        // 读取字节数据，转为message，移交给   Goroutine Pool 处理业务逻辑
}

func (s *session) handlePackage() {
    ...
	err = s.handleTCPPackage()
    ...
}
func (s *session) handleTCPPackage() error {
	conn = s.Connection.(*gettyTCPConn)
	for {
	    bufLen, err = conn.recv(buf)
		pktBuf.Write(buf[:bufLen])
		for {
			pkg, pkgLen, err = s.reader.Read(s, pktBuf.Bytes())	// 将字节流转为pkg
            ...
			s.addTask(pkg)									    // 交给业务逻辑处理
			pktBuf.Next(pkgLen)
		}
	}
	return perrors.WithStack(err)
}
func (s *session) addTask(pkg interface{}) {
	f := func() {
		s.listener.OnMessage(s, pkg)
		s.incReadPkgNum()
	}
	if taskPool := s.EndPoint().GetTaskPool(); taskPool != nil { // 交给协程池执行
		taskPool.AddTask(f)
		return
	}
	f()	// 直接执行
}

func (s *session) handleLoop() {
	for {
		select {
		case <-s.done: ...
		case outPkg, ok = <-s.wQ:
			iovec = iovec[:0]
			for idx := 0; idx < maxIovecNum; idx++ {
				pkgBytes, err = s.writer.Write(s, outPkg)   // 编码
				iovec = append(iovec, pkgBytes)
			}
			err = s.WriteBytesArray(iovec[:]...)
		case <-wheel.After(s.period):
			if flag {
				s.listener.OnCron(s)
			}
		}
	}
}

func helloHandler(w http.ResponseWriter, req *http.Request) {
    io.WriteString(w, "hello, world!\n")
}
func main() {
    http.HandleFunc("/", helloHandler)
    http.ListenAndServe(":12345", nil)
}