我们有一个异步任务计划程序系统,该系统使用golang的exec.Command执行php脚本。每次调度程序从消息队列中提取任务时,它将创建一个新的exec.Command来执行任务。
有时,几乎有数千个任务需要一次执行。在这种情况下,调度程序将创建数千个exec.Command,然后过一会销毁它们。
我想知道是否可以创建一个进程池(或类似的东西),以便我们可以重用exec.Command来减少创建新子进程的成本。
ps:我注意到exec.Command在调用run之后不能重用。
更新 当前的逻辑如下:
func nsqMessageHandler(msg *nsq.Message) error{
var task Task
err:= json.Unmarshal(msg.Body,&task)
....
cmd:=exec.Command("php",task.Payload...)
err:=cmd.Start()
....
err= cmd.Run()
err=cmd.Process.Kill()
...
}
答案 0 :(得分:1)
肯定是。您可以创建一个阻止频道,将作业提交到该频道。然后,您可以通过生成 goroutines 来创建一组“工作人员”,这些工作将工作<渠道作为输入,并具有例如发布进度或结果的输出渠道。现在,工作人员只是在频道上阅读,一旦其中一位找到工作,它将开始工作。
您想防止工作人员从一开始就关闭,因此您需要某种阻止他们的方法。解决此问题的一种方法是使用waitgroup
,如果其中一个关闭,则允许工作程序将waitgroup
索引减少一个。此外,您想停止工作人员,但不能从外部停止goroutine-因此您必须执行一项工作,然后将其传递给工作人员,迫使他们自己停止工作。
// In this example we'll look at how to implement
// a _worker pool_ using goroutines and channels.
package main
import "fmt"
import "time"
// Here's the worker, of which we'll run several
// concurrent instances. These workers will receive
// work on the `jobs` channel and send the corresponding
// results on `results`. We'll sleep a second per job to
// simulate an expensive task.
func worker(id int, jobs <-chan int, results chan<- int) {
for j := range jobs {
fmt.Println("worker", id, "started job", j)
time.Sleep(time.Second)
fmt.Println("worker", id, "finished job", j)
results <- j * 2
}
}
func main() {
// In order to use our pool of workers we need to send
// them work and collect their results. We make 2
// channels for this.
jobs := make(chan int, 100)
results := make(chan int, 100)
// This starts up 3 workers, initially blocked
// because there are no jobs yet.
for w := 1; w <= 3; w++ {
go worker(w, jobs, results)
}
// Here we send 5 `jobs` and then `close` that
// channel to indicate that's all the work we have.
for j := 1; j <= 5; j++ {
jobs <- j
}
close(jobs)
// Finally we collect all the results of the work.
for a := 1; a <= 5; a++ {
<-results
}
}