我的服务器运行了一段时间，创建了大约 200 个连接并做了一些计算并关闭，我发现它占用了大约 2,7G 内存，并且在几天后没有减少。程序本身并没有占用那么多，而且我通过memstats查了一下。通过 cat/proc/11686/status | grep -i threads 我得到了 Threads: 177，所以我认为它占用这么多内存的原因是它创建了很多线程。为什么 go创建这么多线程？是因为我用了太多go func()吗？而且我确定 goroutines 没有增加并且它们正常退出。

附言

我的程序代码太多，所以我排除了细节，只保留主要内容

我的问题是当 go 创建一个线程来做某事时。有这么多线程正常吗？我认为它与代码无关。

主.go

package main

import (
    "sanguo/base/log"
    "fmt"
    "runtime"
    "math/rand"
    "time"
    "net"
    "os"
)

type GameServer struct {
    Host   string
}


func (server *GameServer) Start() {
    // load system data
    log.Debug("/*************************SREVER START********************************/")

    tcpAddr, err := net.ResolveTCPAddr("tcp4", server.Host)
    if err != nil {
        log.Error(err.Error())
        os.Exit(-1)
    }
    go func(){
        for{
            select {
            case <-time.After(30*time.Second):
                LookUp("read memstats")
            }
        }
    }()
    listener, err := net.ListenTCP("tcp", tcpAddr)
    if err != nil {
        log.Error(err.Error())
        os.Exit(-1)
    }
    log.Debug("/*************************SERVER SUCC********************************/")
    for {
        conn, err := listener.AcceptTCP()
        if err != nil {
            continue
        }
        log.Debug("Accept a new connection ", conn.RemoteAddr())
        go handleClient(conn)
    }
}

func handleClient(conn *net.TCPConn) {
    sess := NewSession(conn)
    sess.Start()
}

func main() {
    rand.Seed(time.Now().Unix())

    runtime.GOMAXPROCS(runtime.NumCPU())

    log.SetLevel(0)

    filew := log.NewFileWriter("log", true)
    err := filew.StartLogger()
    if err != nil {
        fmt.Println("Failed start log",err)
        return
    }

    var server GameServer
    server.Host = "127.0.0.1:9999"
    server.Start()
}

session .go

package main

import (
    "io"
    "encoding/binary"
    "encoding/json"
    "github.com/felixge/tcpkeepalive"
    "net"
    "sanguo/base/log"
    "strings"
    "sync"
    "time"
)


type Session struct {

    conn *net.TCPConn //the tcp connection from client

    recvChan      chan *bufferedManager.Token //data from client
    closeNotiChan chan bool   //

    ok   bool
    lock sync.Mutex

}


func NewSession(connection *net.TCPConn) (sess *Session) {
    var client Session

    client.conn = connection

    client.recvChan = make(chan []byte, 1024)
    client.closeNotiChan = make(chan bool)
    client.ok = true

    log.Debug("New Connection", &client)

    kaConn, err := tcpkeepalive.EnableKeepAlive(connection)
    if err != nil {
        log.Debug("EnableKeepAlive err ", err)
    } else {
        kaConn.SetKeepAliveIdle(120 * time.Second)
        kaConn.SetKeepAliveCount(4)
        kaConn.SetKeepAliveInterval(5 * time.Second)
    }
    return &client
}


func (sess *Session) Close() {
    sess.lock.Lock()
    if sess.ok {
        sess.ok = false
        close(sess.closeNotiChan)
        sess.conn.Close()
        log.Trace("Sess Close Succ", sess, sess.uid)
    }
    sess.lock.Unlock()
}

func (sess *Session) handleRecv() {
    defer func(){
        if err := recover(); err != nil {
            log.Critical("Panic", err)
        }
        log.Trace("Session Recv Exit", sess, sess.uid)
        sess.Close()
    }()
    ch := sess.recvChan
    header := make([]byte, 2)
    for {
        /**block until recieve len(header)**/
        n, err := io.ReadFull(sess.conn, header)
        if n == 0 && err == io.EOF {
            //Opposite socket is closed
            log.Warn("Socket Read EOF And Close", sess)
            break
        } else if err != nil {
            //Sth wrong with this socket
            log.Warn("Socket Wrong:", err)
            break
        }
        size := binary.LittleEndian.Uint16(header) + 4
        data := make([]byte, size)
        n, err = io.ReadFull(sess.conn, t.Data)
        if n == 0 && err == io.EOF {
            log.Warn("Socket Read EOF And Close", sess)
            break
        } else if err != nil {
            log.Warn("Socket Wrong:", err)
            break
        }
        ch <- data //send data to Client to process
    }
}

func (sess *Session) handleDispatch() {
    defer func(){
        log.Trace("Session Dispatch Exit",  sess, sess.uid)
        sess.Close()
    }()
    for {
        select {
        case msg, _ := <-sess.recvChan:
            log.Debug("msg", msg)
            sess.SendDirectly("helloworldhellowor", 1)

        case <-sess.closeNotiChan:
                return
        }
    }
}

func (sess *Session) Start() {
    defer func() {
        if err := recover(); err != nil {
            log.Critical("Panic", err)
        }
    }()
    go sess.handleRecv()

    sess.handleDispatch()

    close(sess.recvChan)
    log.Warn("Session Start Exit", sess, sess.uid)
}


func (sess *Session) SendDirectly(back interface{}, op int) bool {
    back_json, err := json.Marshal(back)
    if err != nil {
        log.Error("Can't encode json message ", err, back)
        return false
    }
    log.Debug(sess.uid, "OUT cmd:", op, string(back_json))
    _, err = sess.conn.Write(back_json)
    if err != nil {
        log.Error("send fail", err)
        return false
    }
    return true
}

最佳答案

使用Go，你可以创建很多goroutines，它不应该增加线程数。在您的代码中，运行 Go 代码的线程数受 runtime.NumCPU() 限制。

当 goroutine 必须执行阻塞调用时，例如系统调用，或通过 cgo 调用 C 库时，可能会创建线程。在这种情况下，运行时调度程序会从其调度池中删除运行 goroutine 的线程。如果调度池的线程少于 GOMAXPROCS，那么将创建一个新线程。

您可以在此处找到有关其工作原理的更多信息: https://softwareengineering.stackexchange.com/questions/222642/are-go-langs-goroutine-pools-just-green-threads/222694#222694

要了解代码生成线程的原因，您必须调查导致阻塞系统调用或 C 调用的所有代码路径。请注意，与网络相关的调用是非阻塞的，因为它们会被标准库自动多路复用。但是，如果你执行一些磁盘I/O，或者调用外部库，这将产生线程。

例如，您的代码中使用的日志记录库可能会执行一些阻塞 I/O，从而导致创建线程(特别是如果生成的文件托管在慢速设备上)。

关于go - 为什么我的 golang 程序创建了这么多线程？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/27600587/