Go语言构建高性能异步TCP服务器

package main

import (
    "bufio"
    "fmt"
    "io"
    "log"
    "net"
    "os"
    "os/signal"
    "strconv"
    "strings"
    "syscall"
    "time"
)

const (
    SERVER_HOST = "localhost"
    SERVER_PORT = "8080"
    SERVER_TYPE = "tcp"
)

func main() {
    fmt.Println("启动", SERVER_TYPE, "服务器在", SERVER_HOST+":"+SERVER_PORT)

    // 1. 监听指定端口
    listener, err := net.Listen(SERVER_TYPE, SERVER_HOST+":"+SERVER_PORT)
    if err != nil {
        log.Fatalf("监听失败: %s", err.Error())
        os.Exit(1)
    }
    defer listener.Close() // 确保在main函数退出时关闭监听器

    // 2. 优雅关闭处理
    // 创建一个通道用于接收操作系统信号
    sigChan := make(chan os.Signal, 1)
    // 注册要监听的信号：中断（Ctrl+C）和终止
    signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

    go func() {
        sig := <-sigChan // 阻塞直到接收到信号
        fmt.Printf("\n接收到信号 %v，服务器正在关闭...\n", sig)
        listener.Close() // 关闭监听器，停止接受新连接
        // 在这里可以添加等待所有Goroutine完成的逻辑，例如使用sync.WaitGroup
        os.Exit(0)
    }()

    // 3. 循环接受客户端连接
    for {
        conn, err := listener.Accept()
        if err != nil {
            // 如果是由于listener关闭导致的错误，则退出循环
            if strings.Contains(err.Error(), "use of closed network connection") {
                fmt.Println("监听器已关闭，停止接受新连接。")
                break
            }
            log.Printf("接受连接失败: %s", err.Error())
            continue // 继续尝试接受下一个连接
        }
        fmt.Printf("新连接来自 %s\n", conn.RemoteAddr().String())

        // 4. 为每个新连接启动一个Goroutine进行处理
        go handleConnection(conn)
    }
}

// handleConnection 处理单个客户端连接
func handleConnection(conn net.Conn) {
    // 确保连接在函数退出时关闭
    defer func() {
        fmt.Printf("关闭连接 %s\n", conn.RemoteAddr().String())
        conn.Close()
    }()

    reader := bufio.NewReader(conn)
    for {
        // 设置读取超时，防止客户端长时间不发送数据导致阻塞
        conn.SetReadDeadline(time.Now().Add(5 * time.Minute))

        // 尝试读取一行数据，直到遇到换行符
        message, err := reader.ReadString('\n')
        if err != nil {
            if err == io.EOF {
                fmt.Printf("客户端 %s 已断开连接。\n", conn.RemoteAddr().String())
            } else if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
                fmt.Printf("读取客户端 %s 数据超时，关闭连接。\n", conn.RemoteAddr().String())
            } else {
                log.Printf("读取客户端 %s 数据错误: %s\n", conn.RemoteAddr().String(), err.Error())
            }
            return // 发生错误或EOF时，关闭连接并退出Goroutine
        }

        // 清除消息中的空格和换行符
        trimmedMessage := strings.TrimSpace(message)
        fmt.Printf("接收到来自 %s 的消息: %s\n", conn.RemoteAddr().String(), trimmedMessage)

        // 模拟异步计算
        // 在实际应用中，这里可能涉及数据库查询、API调用、复杂计算等
        // 异步计算通常意味着它可能需要一些时间，并且不应该阻塞其他连接
        response := simulateAsyncTask(trimmedMessage)

        // 将计算结果发送回客户端
        _, err = conn.Write([]byte(response + "\n"))
        if err != nil {
            log.Printf("写入数据到客户端 %s 错误: %s\n", conn.RemoteAddr().String(), err.Error())
            return
        }
    }
}

// simulateAsyncTask 模拟一个耗时的异步任务
func simulateAsyncTask(input string) string {
    fmt.Printf("正在为输入 '%s' 执行异步计算...\n", input)
    // 模拟耗时操作
    time.Sleep(2 * time.Second) // 暂停2秒

    // 简单的计算示例：尝试将输入转换为数字并加1
    num, err := strconv.Atoi(input)
    if err == nil {
        return fmt.Sprintf("计算结果: %d (处理了 '%s')", num+1, input)
    }
    return fmt.Sprintf("无法计算，收到消息: '%s'", input)
}