multithreading - GO:在简单的 tcp 服务器上超过 10000 个线程？

Question

我需要编写一个可以处理超过 500k 连接的 tcp 服务器。

我在 golang 上写了一个简单的服务器，但是当连接超过 10k 时，服务器崩溃并显示错误消息“runtime: program exceeds 10000-thread limit fatal error: thread exhaustion”。

服务器在上一个 Linux 版本中运行。 go 可以使用 epoll 进行 tcp 连接，使其异步并使用很少的 fd。那么为什么服务器会超过线程限制呢？!

我的简单服务器:

package main
import (
    "strconv"
    "net"
    "log"
    "time"
    "bufio"
    "io"
)

type Handler struct {
    conn   net.Conn
    closed chan bool
}

func (h *Handler) Listen() { // listen connection for incomming data
    defer h.conn.Close()
    bf := bufio.NewReader(h.conn)
    for {
        line, _, err := bf.ReadLine()
        if err != nil {
            if err == io.EOF {
                log.Println("End connection")
            }
            h.closed <- true // send to dispatcher, that connection is closed
            return
        }

        // ... some business logic with data
    }
}

type Dispatcher struct {
    handlers map[string]*Handler `map[ip]*Handler`
}

func (d *Dispatcher) AddHandler(conn net.Conn) {
    addr := conn.RemoteAddr().String()
    handler := &Handler{conn, make(chan bool, 1)}
    d.handlers[addr] = handler

    go handler.Listen()

    <-handler.closed // when connection closed, remove handler from handlers
    delete(d.handlers, addr)
}

func (d *Dispatcher) ListenHandlers(port int) {
    sport := strconv.Itoa(port)

    ln, err := net.Listen("tcp", ":" + sport)
    if err != nil {
        log.Println(err)
        return
    }

    defer ln.Close()

    for {
        conn, err := ln.Accept() // accept connection
        if err != nil {
            log.Println(err)
            continue
        }

        tcpconn := conn.(*net.TCPConn)
        tcpconn.SetKeepAlive(true)
        tcpconn.SetKeepAlivePeriod(10 * time.Second)

        go d.AddHandler(conn)
    }
}

func main() {
    dispatcher := &Dispatcher{make(map[string]*Handler)}
    dispatcher.ListenHandlers(3000)
}

2015 年 10 月 11 日更新
问题是 https://github.com/felixge/tcpkeepalive图书馆。请不要使用它:)

Answer 1

问题是 https://github.com/felixge/tcpkeepalive图书馆。该库获取套接字文件描述符 (fd)，然后复制并使用以阻塞模式运行的新 fd。因此，go 在每次连接时创建新线程。 Go 不会终止创建的线程(因为这是本地 golang 行为)，并且在某些时候 go 失败并显示“超过 10000 个线程”。而已 !请不要使用它:)