去达到进程的最大线程数？

Question

我正在尝试使用 Go 进行一些文件系统使用分析，并且通过将几乎所有内容生成为 goroutine 并依靠 Go VM（和 GOMAXPROCS）来管理它来尽可能快地编写代码。我一直在看着这段代码运行（非常快），直到它停止运行。我检查了顶部，它列出了我的进程有 1500 个线程。我想也许我已经达到了一些限制，因此该进程在等待操作系统时陷入僵局。我检查了我的操作系统 (FreeBSD) 限制，果然它被列为每个进程最多 1500 个线程。很惊讶，我检查了 Go 文档，它说 GOMAXPROCS 只是对运行线程的限制，但阻塞的线程不计算在内。所以我的问题：可以说我不能依靠 Go VM 作为全局池来防止达到这些类型的操作系统限制吗？有没有一种惯用的方法来处理这个问题（好吧，这只是我使用 Go 的第二天）？特别是，当我使用完频道后，除了同步关闭频道之外，我还没有找到其他好方法。有没有更好的办法？我想抽象掉样板（与 go 例程并行映射并在完成后关闭通道），是否有一种类型安全的方法可以在没有泛型的情况下做到这一点？这是我当前的代码：func AnalyzePaths(paths chan string) chan AnalyzedPath {    analyzed := make(chan AnalyzedPath)    go func() {        group := sync.WaitGroup{}        for path := range paths {            group.Add(1)            go func(path string) {                defer group.Done()                analyzed <- Analyze(path)            }(path)        }        group.Wait()        close(analyzed)    }()    return analyzed}func GetPaths(roots []string) chan string {    globbed := make(chan string)    go func() {        group := sync.WaitGroup{}        for _, root := range roots {            group.Add(1)            go func(root string) {                defer group.Done()                for _, path := range glob(root) {                    globbed <- path                }            }(root)        }        group.Wait()        close(globbed)    }()    return globbed}func main() {    paths := GetPaths(patterns)    for analyzed := range AnalyzePaths(paths) {        fmt.Println(analyzed)    }}

Answer 1

大约 2 个月前（或更多）语言开发人员谈到侵入线程计数控制（和一些其他限制）。所以我们可以期待很快看到它。一个月或更长时间前，我开发了这个问题，在我的 linux 机器上发现 GOMAXPROCS 没有超过 256 的值。如果我向它发送 300 或更多，结果总是 256。但我发现 goroutines 不是线程。Goroutines 可以存在于一个线程中。

至于惯用同步 - 我认为没有必要同步太多。在我的代码中，我通常使用 goroutine 仅通过通道进行通信的想法。通道应该作为 goroutine 的参数传递。

func main() {

    ch1 := make(chan SomeType1)

    ch2 := make(chan SomeType2)

    go generator(ch1, ch2)

    go processor(ch1, ch2)

    // here main func becomes waiting until it capture 2 of ch2-finished-signals 

    <- ch2

    <- ch2

    // usually we don't need the exact values of ch2-signals,

    // so we assign it to nothing 

}

func generator(ch1 chan SomeType1, ch2 chan SomeType2) {

    for (YOUR_CONDITION){

        // generate something

        //....

        // send to channel

        ch1 <- someValueOfType1

    }

    ch1 <- magicStopValue

    ch2 <- weAreFinishedSignal1

}

func processor(ch1 chan SomeType1, ch2 chan SomeType2) {

    // "read" value from ch1 

    value := <-ch1

    for value != magicStopValue {

        // make some processing

        // ....

        //get next value from ch1 and replay processing

        value = <- ch1

    }

    // here we can send signal that goroutine2 is finished

    ch2 <- weAreFinishedSignal2

}

如果 goroutines 在一个线程中，它们的通信速度会更快。对我来说，通道性能差得很远，但足以满足多种用途。