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

package main

import (
    "bufio"
    "fmt"
    "log"
    "net"
    "strings"
    "time"
)

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

func main() {
    fmt.Printf("启动TCP服务器在 %s:%s...\n", SERVER_HOST, SERVER_PORT)

    // 1. 监听TCP端口
    listener, err := net.Listen(SERVER_TYPE, SERVER_HOST+":"+SERVER_PORT)
    if err != nil {
        log.Fatalf("无法监听端口: %v", err)
    }
    defer listener.Close() // 确保在main函数退出时关闭监听器

    fmt.Println("服务器已启动，等待客户端连接...")

    // 2. 循环接受客户端连接
    for {
        conn, err := listener.Accept()
        if err != nil {
            log.Printf("接受连接失败: %v", err)
            continue // 继续接受下一个连接
        }
        // 3. 为每个新连接启动一个goroutine进行处理
        go handleConnection(conn)
    }
}

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

    log.Printf("新连接来自: %s", conn.RemoteAddr().String())

    reader := bufio.NewReader(conn)

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

        // 读取客户端发送的数据，直到遇到换行符
        netData, err := reader.ReadString('\n')
        if err != nil {
            if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
                log.Printf("读取超时，关闭连接: %s", conn.RemoteAddr().String())
                return // 读取超时，退出处理函数
            }
            log.Printf("读取数据失败或连接已关闭: %v, %s", err, conn.RemoteAddr().String())
            return // 客户端关闭连接或发生其他错误，退出处理函数
        }

        // 清理数据，移除末尾的换行符
        trimmedData := strings.TrimSpace(netData)
        if trimmedData == "" {
            continue // 忽略空数据
        }
        log.Printf("接收到来自 %s 的数据: %s", conn.RemoteAddr().String(), trimmedData)

        // 模拟异步计算：耗时操作
        // 在实际应用中，这里可能是数据库查询、外部API调用或复杂的计算
        // 由于是在一个独立的goroutine中执行，不会阻塞其他客户端连接
        fmt.Printf("开始为 %s 处理数据: %s (模拟异步计算...)\n", conn.RemoteAddr().String(), trimmedData)
        time.Sleep(2 * time.Second) // 模拟2秒的计算延迟
        result := fmt.Sprintf("服务器已处理 '%s'，结果是: %s\n", trimmedData, strings.ToUpper(trimmedData))
        fmt.Printf("完成为 %s 处理数据: %s\n", conn.RemoteAddr().String(), trimmedData)

        // 将结果写入连接返回给客户端
        conn.SetWriteDeadline(time.Now().Add(10 * time.Second)) // 设置写入超时
        _, err = conn.Write([]byte(result))
        if err != nil {
            log.Printf("写入数据失败: %v, %s", err, conn.RemoteAddr().String())
            return // 写入失败，退出处理函数
        }
    }
}

nc localhost 8080

hello world

package main

import (
    "bufio"
    "fmt"
    "log"
    "net"
    "os"
    "strings"
    "time"
)

func main() {
    // 连接到服务器
    conn, err := net.Dial("tcp", "localhost:8080")
    if err != nil {
        log.Fatalf("连接服务器失败: %v", err)
    }
    defer conn.Close()
    fmt.Println("已连接到服务器。输入消息，按回车发送。")

    go func() {
        reader := bufio.NewReader(conn)
        for {
            // 读取服务器响应
            message, err := reader.ReadString('\n')
            if err != nil {
                log.Printf("读取服务器响应失败: %v", err)
                return
            }
            fmt.Print("服务器响应: " + message)
        }
    }()

    // 从标准输入读取用户消息并发送给服务器
    scanner := bufio.NewScanner(os.Stdin)
    for scanner.Scan() {
        text := scanner.Text()
        if strings.TrimSpace(text) == "" {
            continue
        }
        _, err := fmt.Fprintf(conn, text+"\n")
        if err != nil {
            log.Printf("发送数据失败: %v", err)
            return
        }
    }

    if err := scanner.Err(); err != nil {
        log.Printf("读取标准输入失败: %v", err)
    }
}