Question

简短版：

Golang是否有可能并行生成许多外部进程（shell命令），这样它就不会为每个外部进程启动一个操作系统线程。 ..并且在完成后仍然能够接收输出？

更长的版本：

在Elixir中，如果使用端口，则可以生成数千个外部进程，而不会真正增加Erlang虚拟机中的线程数。

E.g。以下代码片段启动了2500个外部sleep进程，仅由Erlang VM下的20个操作系统线程管理：

defmodule Exmultiproc do
  for _ <- 1..2500 do
    cmd = "sleep 3600"
    IO.puts "Starting another process ..."
    Port.open({:spawn, cmd}, [:exit_status, :stderr_to_stdout])
  end
  System.cmd("sleep", ["3600"])
end

（假设您将ulimit -n设置为较高的数字，例如10000）

另一方面，Go中的以下代码（应该执行相同的操作 - 启动2500个外部sleep进程）也会启动2500 操作系统线程。所以它显然会启动一个操作系统线程每个（阻塞？）系统调用（以便不阻塞整个CPU，或类似的，如果我理解正确的话）：

package main

import (
    "fmt"
    "os/exec"
    "sync"
)

func main() {
    wg := new(sync.WaitGroup)
    for i := 0; i < 2500; i++ {
        wg.Add(1)
        go func(i int) {
            fmt.Println("Starting sleep ", i, "...")
            cmd := exec.Command("sleep", "3600")
            _, err := cmd.Output()
            if err != nil {
                panic(err)
            }
            fmt.Println("Finishing sleep ", i, "...")
            wg.Done()
        }(i)
    }
    fmt.Println("Waiting for WaitGroup ...")
    wg.Wait()
    fmt.Println("WaitGroup finished!")
}

因此，我想知道是否有办法编写Go代码，以便它与Elixir代码类似，而不是为每个外部进程打开一个操作系统线程？

我基本上正在寻找一种方法来管理至少几千个外部长时间运行（最多10天）的流程，其方式是尽可能减少任何虚拟或物理限制的问题。操作系统。

（对不起代码中的任何错误，因为我是Elixir的新手，而且是Go的新手。我很想知道我做过的任何错误。）

编辑：澄清了并行运行长时间运行流程的要求。

Answer 1

我发现如果我们不进行wait处理，Go运行时将无法启动2500 operating system threads。所以请使用cmd.Output（）以外的cmd.Start（）。

但是，如果不通过golang os包消耗OS线程，就不可能读取进程的stdout。我认为这是因为os包不使用非块io来读取管道。

底层，下面的程序在我的Linux上运行良好，虽然它阻止了进程的标准输出，因为@JimB在评论中说，也许是因为我们的输出很小并且它适合系统缓冲区。

func main() {
    concurrentProcessCount := 50
    wtChan := make(chan *result, concurrentProcessCount)
    for i := 0; i < concurrentProcessCount; i++ {
        go func(i int) {
            fmt.Println("Starting process ", i, "...")
            cmd := exec.Command("bash", "-c", "for i in 1 2 3 4 5; do echo to sleep $i seconds;sleep $i;echo done;done;")
            outPipe,_ := cmd.StdoutPipe()
            err := cmd.Start()
            if err != nil {
                panic(err)
            }
            <-time.Tick(time.Second)
            fmt.Println("Finishing process ", i, "...")
            wtChan <- &result{cmd.Process, outPipe}
        }(i)
    }

    fmt.Println("root:",os.Getpid());

    waitDone := 0
    forLoop:
    for{
        select{
        case r:=<-wtChan:
            r.p.Wait()
            waitDone++
            output := &bytes.Buffer{}
            io.Copy(output, r.b)
            fmt.Println(waitDone, output.String())
            if waitDone == concurrentProcessCount{
                break forLoop
            }
        }
    }
}

Can Go可以生成并与外部进程通信，而无需为每个外部进程启动一个OS线程吗？

1 个答案: