Version corta:

¿Es posible en Golang generar una serie de procesos externos (comandos de shell)en paralelo, de modo que no comience unohilo del sistema operativo por proceso externo ... y aún así poder recibir su salida cuando haya terminado?

Versión más larga:

En Elixir, si usa puertos, puede generar miles de procesos externos sin aumentar realmente el número de subprocesos en la máquina virtual Erlang.

P.ej. el siguiente fragmento de código, que inicia 2500 externossleep procesos, solo lo gestionan 20hilos del sistema operativo bajo la máquina virtual Erlang:

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

(Siempre que establezcaulimit -n a un número alto, como 10000)

Por otro lado, el siguiente código en Go, que se supone que debe hacer lo mismo: iniciar 2500 externossleep procesos - también comienza 2500hilos del sistema operativo. Entonces obviamente comienza unohilo del sistema operativo por llamada de sistema (¿bloqueo?) (para no bloquear toda la CPU, o similar, si entiendo correctamente):

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!")
}

Por lo tanto, me preguntaba si hay una manera de escribir el código Go para que haga lo mismo que el código Elixir, no abrir unohilo del sistema operativo por proceso externo?

Básicamente estoy buscando una manera de administrar al menos unos pocos miles de procesos externos de larga duración (hasta 10 días), de manera que cause la menor cantidad de problemas posible con cualquier límite virtual o físico en el sistema operativo.

(Perdón por los errores en los códigos, ya que soy nuevo en Elixir y bastante nuevo en Go. Estoy ansioso por conocer los errores que estoy cometiendo).

EDITAR: se aclaró sobre el requisito de ejecutar los procesos de larga ejecución en paralelo.