Golang高并发服务器稳定性优化：文件描述符与资源管理

ulimit -n 99999

* soft nofile 99999
* hard nofile 99999

ulimit -a

lsof -p <PID>

package main

import (
    "encoding/binary"
    "log"
    "math/rand"
    "net"
    "sync"
    "time"
)

// 假设proto包定义了L1结构和LINK_TIMEOUT_NS
type L1 struct {
    ID    uint32
    Value uint16
}

const LINK_TIMEOUT_NS = 5 * time.Second // 示例超时时间
const ClientCount = 1000

func main() {
    // 启动一个简单的TCP服务器以供测试
    go startServer("127.0.0.1:10000")
    time.Sleep(1 * time.Second) // 等待服务器启动

    srvAddr := "127.0.0.1:10000"
    var wg sync.WaitGroup
    wg.Add(ClientCount)
    for i := 0; i < ClientCount; i++ {
        go func(i int) {
            client(i, srvAddr)
            wg.Done()
        }(i)
    }
    wg.Wait()
    log.Println("All clients finished.")
}

func client(i int, srvAddr string) {
    conn, err := net.Dial("tcp", srvAddr)
    if err != nil {
        log.Printf("Client %d: Err:Dial(): %v", i, err) // 使用Printf避免Fatalln导致整个程序退出
        return
    }
    // 确保连接在函数退出时关闭，无论如何
    defer func() {
        if err := conn.Close(); err != nil {
            log.Printf("Client %d: Error closing connection: %v", i, err)
        }
    }()

    // 设置读写超时，防止阻塞
    if err := conn.SetDeadline(time.Now().Add(LINK_TIMEOUT_NS)); err != nil {
        log.Printf("Client %d: Warning: SetDeadline failed: %v", i, err)
    }

    l1 := L1{uint32(i), uint16(rand.Uint32() % 10000)}
    // log.Printf("%s WL1 %v", conn.LocalAddr(), l1) // 避免过多日志输出影响性能

    // 写入数据
    err = binary.Write(conn, binary.BigEndian, &l1)
    if err != nil {
        // 区分EOF和其他写入错误
        if err.Error() == "EOF" { // net.Dial/Write的EOF错误通常是连接断开
            log.Printf("Client %d: Write error (EOF): %v", i, err)
        } else {
            log.Printf("Client %d: Write error: %v", i, err)
        }
        return
    }

    // 模拟读取服务器响应（如果需要）
    // var response L1
    // err = binary.Read(conn, binary.BigEndian, &response)
    // if err != nil {
    //  if err == io.EOF {
    //      log.Printf("Client %d: Read error (EOF): %v", i, err)
    //  } else {
    //      log.Printf("Client %d: Read error: %v", i, err)
    //  }
    //  return
    // }
    // log.Printf("Client %d: Received response: %v", i, response)
}

// 简单服务器，用于测试客户端连接
func startServer(addr string) {
    listener, err := net.Listen("tcp", addr)
    if err != nil {
        log.Fatalf("Server: Listen error: %v", err)
    }
    defer listener.Close()
    log.Printf("Server listening on %s", addr)

    for {
        conn, err := listener.Accept()
        if err != nil {
            log.Printf("Server: Accept error: %v", err)
            continue
        }
        go handleConnection(conn)
    }
}

func handleConnection(conn net.Conn) {
    defer func() {
        if err := conn.Close(); err != nil {
            log.Printf("Server: Error closing connection: %v", err)
        }
    }()

    // 设置连接超时
    if err := conn.SetDeadline(time.Now().Add(LINK_TIMEOUT_NS)); err != nil {
        log.Printf("Server: Warning: SetDeadline failed: %v", err)
    }

    var l1 L1
    err := binary.Read(conn, binary.BigEndian, &l1)
    if err != nil {
        if err.Error() == "EOF" {
            // 客户端正常关闭连接或连接已断开
            // log.Printf("Server: Client %s disconnected (EOF)", conn.RemoteAddr())
        } else {
            log.Printf("Server: Read error from %s: %v", conn.RemoteAddr(), err)
        }
        return
    }
    // log.Printf("Server: Received from %s: %v", conn.RemoteAddr(), l1)

    // 模拟处理后回写数据
    // err = binary.Write(conn, binary.BigEndian, &l1)
    // if err != nil {
    //  log.Printf("Server: Write error to %s: %v", conn.RemoteAddr(), err)
    // }
}

package main

import (
    "net/http"
    _ "net/http/pprof" // 导入此包以启用pprof HTTP接口
    // ... 其他导入
)

func main() {
    go func() {
        log.Println(http.ListenAndServe("localhost:6060", nil))
    }()
    // ... 你的主程序逻辑
}

// 示例：设置连接的读写超时
if err := conn.SetDeadline(time.Now().Add(timeoutDuration)); err != nil {
    log.Printf("Error setting deadline: %v", err)
}