Go语言并发多端口TCP服务实现教程：同时运行HTTP与自定义协议服务器

package main

import (
    "fmt"
    "io"
    "log"
    "net"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"
)

// serveHTTP 启动一个HTTP服务器
func serveHTTP(port string) {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        log.Printf("HTTP request received from %s on port %s: %s %s", r.RemoteAddr, port, r.Method, r.URL.Path)
        fmt.Fprintf(w, "Hello from HTTP server on port %s!", port)
    })

    log.Printf("HTTP server listening on :%s", port)
    // http.ListenAndServe 会阻塞，因此需要在一个goroutine中运行
    if err := http.ListenAndServe(":"+port, nil); err != nil && err != http.ErrServerClosed {
        log.Fatalf("HTTP server error on port %s: %v", port, err)
    }
    log.Printf("HTTP server on port %s stopped.", port)
}

// serveCustomTCP 启动一个自定义TCP服务器
func serveCustomTCP(port string) {
    listener, err := net.Listen("tcp", ":"+port)
    if err != nil {
        log.Fatalf("Custom TCP server error on port %s: %v", port, err)
    }
    defer listener.Close() // 确保在函数退出时关闭监听器
    log.Printf("Custom TCP server listening on :%s", port)

    for {
        conn, err := listener.Accept()
        if err != nil {
            // 如果监听器已关闭，Accept会返回错误
            if opErr, ok := err.(*net.OpError); ok && opErr.Op == "accept" && opErr.Err.Error() == "use of closed network connection" {
                log.Printf("Custom TCP server on port %s listener closed, stopping accept loop.", port)
                return
            }
            log.Printf("Error accepting connection on port %s: %v", port, err)
            continue
        }
        // 为每个新连接启动一个goroutine进行处理
        go handleCustomConnection(conn, port)
    }
}

// handleCustomConnection 处理自定义TCP连接
func handleCustomConnection(conn net.Conn, port string) {
    defer conn.Close() // 确保连接关闭
    log.Printf("Accepted custom connection from %s on port %s", conn.RemoteAddr(), port)

    buf := make([]byte, 1024)
    for {
        // 设置读取超时，防止客户端不发送数据导致阻塞
        conn.SetReadDeadline(time.Now().Add(5 * time.Minute))
        n, err := conn.Read(buf)
        if err != nil {
            if err == io.EOF {
                log.Printf("Client %s on port %s disconnected.", conn.RemoteAddr(), port)
            } else if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
                log.Printf("Read timeout for client %s on port %s, closing connection.", conn.RemoteAddr(), port)
            } else {
                log.Printf("Error reading from custom connection %s on port %s: %v", conn.RemoteAddr(), port, err)
            }
            return
        }

        receivedData := string(buf[:n])
        log.Printf("Received %d bytes from %s on port %s: %s", n, conn.RemoteAddr(), port, receivedData)

        response := fmt.Sprintf("Echo from custom server on port %s: %s", port, receivedData)
        _, err = conn.Write([]byte(response))
        if err != nil {
            log.Printf("Error writing to custom connection %s on port %s: %v", conn.RemoteAddr(), port, err)
            return
        }
    }
}

func main() {
    // 创建一个通道用于接收操作系统信号
    stopChan := make(chan os.Signal, 1)
    signal.Notify(stopChan, syscall.SIGINT, syscall.SIGTERM) // 监听中断和终止信号

    // 启动HTTP服务器（使用8080端口，避免权限问题）
    go serveHTTP("8080")

    // 启动自定义TCP服务器
    go serveCustomTCP("8088")

    // 阻塞主Goroutine，直到接收到停止信号
    <-stopChan
    log.Println("Received shutdown signal, gracefully stopping servers...")

    // 在实际应用中，这里需要实现服务器的优雅关机逻辑
    // 例如，对于HTTP服务器可以使用 http.Server.Shutdown()
    // 对于自定义TCP服务器，需要关闭 listener 并等待所有连接处理完毕
    // 简单起见，这里仅演示信号处理，实际关机逻辑会更复杂
    time.Sleep(2 * time.Second) // 留一些时间给goroutine处理
    log.Println("Servers stopped.")
}