Golang TCP服务器应用CPU占用过高问题已解决

Golang TCP服务器应用CPU占用过高问题已解决 我正在尝试在TCP服务器应用中使用以下代码，运行正常但CPU使用率达到了100%。有人能帮我吗？

package main

import (
	"bufio"
	"bytes"
	"encoding/hex"
	"log"
	"net"
	"strings"
)

// Client holds info about connection
type TCPClient struct {
	conn   net.Conn
	Server *server
}

// TCP server
type server struct {
	clients                  []*TCPClient
	address                  string // Address to open connection: localhost:9999
	onNewClientCallback      func(c *TCPClient)
	onClientConnectionClosed func(c *TCPClient, err error)
	onNewMessage             func(c *TCPClient, message string)
}

// dropCR drops a terminal \r from the data.
func dropCR(data []byte) []byte {
	if len(data) > 0 && data[len(data)-1] == '\r' {
		return data[0 : len(data)-1]
	}
	return data
}

func ScanCRLF(data []byte, atEOF bool) (advance int, token []byte, err error) {
	if atEOF && len(data) == 0 {
		return 0, nil, nil
	}
	if i := bytes.Index(data, []byte{'\r'}); i >= 0 {
		// We have a full newline-terminated line.
		return i + 1, dropCR(data[0:i]), nil
	}
	// If we're at EOF, we have a final, non-terminated line. Return it.
	if atEOF {
		return len(data), dropCR(data), nil
	}
	// Request more data.
	return 0, nil, nil
}

// Read client data from channel
func (c *TCPClient) listen() {


	for {
		message, _ := bufio.NewReader(c.conn).ReadString('\r')
		Rec := strings.TrimSpace(strings.ToUpper(string(message)))
		c.Server.onNewMessage(c, strings.Replace(Rec, "\r", "", -1))
	}

	go c.listen()
}

// Send text message to client
func (c *TCPClient) Send(message string) error {
	hexbytes, _ := hex.DecodeString(message)
	_, err := c.conn.Write([]byte(hexbytes))
	return err
}

func (c *TCPClient) Conn() net.Conn {
	return c.conn
}

func (c *TCPClient) Close() error {
	return c.conn.Close()
}

// Called right after server starts listening new client
func (s *server) OnNewClient(callback func(c *TCPClient)) {
	s.onNewClientCallback = callback
}

// Called right after connection closed
func (s *server) OnClientConnectionClosed(callback func(c *TCPClient, err error)) {
	s.onClientConnectionClosed = callback
}

// Called when Client receives new message
func (s *server) OnNewMessage(callback func(c *TCPClient, message string)) {
	s.onNewMessage = callback
}

// Start network server
func (s *server) Listen() {
	listener, err := net.Listen("tcp", s.address)
	if err != nil {
		log.Fatal("Error starting TCP server.")
	}
	defer listener.Close()

	for {
		conn, _ := listener.Accept()
		client := &TCPClient{
			conn:   conn,
			Server: s,
		}
		go client.listen()
		s.onNewClientCallback(client)
	}
}

// Creates new tcp server instance
func NewTCP(address string) *server {
	server := &server{
		address: address,
	}

	server.OnNewClient(func(c *TCPClient) {})
	server.OnNewMessage(func(c *TCPClient, message string) {})
	server.OnClientConnectionClosed(func(c *TCPClient, err error) {})

	return server
}