Go语言并发TCP服务器：高效处理多客户端连接

// 错误示范：尝试传递 *net.Conn
func handleClient(con *net.Conn) {
    // con.RemoteAddr undefined (type *net.Conn has no field or method RemoteAddr)
    // ...
}

// 在主循环中调用
con, err := listener.Accept()
if err != nil {
    // 处理错误
    return
}
go handleClient(&con) // 试图取地址，但con本身已是接口值

// 正确示范：直接传递 net.Conn 接口类型
func handleClient(conn net.Conn) {
    // 确保连接在函数结束时关闭，释放资源
    defer conn.Close()

    // 现在可以正常访问连接的方法
    remoteAddr := conn.RemoteAddr().String()
    fmt.Printf("处理来自 %s 的连接\n", remoteAddr)

    // 示例：从客户端读取数据并回写
    buffer := make([]byte, 1024)
    for {
        n, err := conn.Read(buffer)
        if err != nil {
            if err == io.EOF {
                fmt.Printf("客户端 %s 已断开连接\n", remoteAddr)
            } else {
                fmt.Printf("读取数据错误：%v\n", err)
            }
            return
        }
        fmt.Printf("从 %s 收到消息: %s\n", remoteAddr, string(buffer[:n]))

        // 回写数据
        _, err = conn.Write([]byte("服务器已收到您的消息: " + string(buffer[:n])))
        if err != nil {
            fmt.Printf("写入数据错误：%v\n", err)
            return
        }
    }
}

package main

import (
    "fmt"
    "io"
    "net"
    "time"
)

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

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

    remoteAddr := conn.RemoteAddr().String()
    fmt.Printf("接受新连接: %s\n", remoteAddr)

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

    buffer := make([]byte, 1024)
    for {
        // 从连接中读取数据
        n, err := conn.Read(buffer)
        if err != nil {
            if err == io.EOF {
                fmt.Printf("客户端 %s 已断开连接 (EOF)\n", remoteAddr)
            } else if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
                fmt.Printf("客户端 %s 读取超时\n", remoteAddr)
            } else {
                fmt.Printf("从 %s 读取数据错误: %v\n", remoteAddr, err)
            }
            return // 发生错误或连接关闭，退出循环
        }

        receivedMessage := string(buffer[:n])
        fmt.Printf("从 %s 收到消息: %s\n", remoteAddr, receivedMessage)

        // 向客户端回写数据
        response := fmt.Sprintf("服务器已收到您的消息: '%s'\n", receivedMessage)
        _, err = conn.Write([]byte(response))
        if err != nil {
            fmt.Printf("向 %s 写入数据错误: %v\n", remoteAddr, err)
            return // 写入失败，退出循环
        }

        // 每次成功读取后重置读取超时
        conn.SetReadDeadline(time.Now().Add(5 * time.Minute))
    }
}

func main() {
    // 监听TCP端口
    listener, err := net.Listen(SERVER_TYPE, SERVER_HOST+":"+SERVER_PORT)
    if err != nil {
        fmt.Printf("监听错误: %v\n", err)
        return
    }
    defer listener.Close() // 确保监听器在main函数退出时关闭

    fmt.Printf("服务器正在 %s://%s:%s 上监听...\n", SERVER_TYPE, SERVER_HOST, SERVER_PORT)

    for {
        // 接受新的连接
        conn, err := listener.Accept()
        if err != nil {
            fmt.Printf("接受连接错误: %v\n", err)
            continue // 继续接受下一个连接
        }

        // 为每个新连接启动一个goroutine来处理
        go handleClient(conn)
    }
}