我试图用goroutines编写一个简单的工作池。
work_channel？代码：
package main
import (
"fmt"
"math/rand"
"sync"
"time"
)
func worker(id string, work string, o chan string, wg *sync.WaitGroup) {
defer wg.Done()
sleepMs := rand.Intn(1000)
fmt.Printf("worker '%s' received: '%s', sleep %dms\n", id, work, sleepMs)
time.Sleep(time.Duration(sleepMs) * time.Millisecond)
o <- work + fmt.Sprintf("-%dms", sleepMs)
}
func main() {
var work_channel = make(chan string)
var results_channel = make(chan string)
// create goroutine per item in work_channel
go func() {
var c = 0
var wg sync.WaitGroup
for work := range work_channel {
wg.Add(1)
go worker(fmt.Sprintf("%d", c), work, results_channel, &wg)
c++
}
wg.Wait()
fmt.Println("closing results channel")
close(results_channel)
}()
// add work to the work_channel
go func() {
for c := 'a'; c < 'z'; c++ {
work_channel <- fmt.Sprintf("%c", c)
}
close(work_channel)
fmt.Println("sent work to work_channel")
}()
for x := range results_channel {
fmt.Printf("result: %s\n", x)
}
}
答案 0 :(得分：27)
您的解决方案在任何意义上都不是工作者goroutine池：您的代码不会限制并发goroutine，并且它不会重复使用＆＃34; goroutines（收到新工作时总会开始新的）。
在Bruteforce MD5 Password cracker发布时，您可以使用producer-consumer pattern。你可以有一个指定的生产者 goroutine，它可以生成作业（要做的事情/计算），并在作业频道上发送它们。您可以拥有一个固定的使用者 goroutines池（例如其中的5个），它们将循环通过提供作业的通道，并且每个都可以执行/完成接收的作业。
生产者 goroutine可以在生成并发送所有作业时关闭jobs频道，正确发信号通知消费者将不再有作业。通道上的for ... range构造处理＆＃34;关闭＆＃34;事件并正确终止。请注意，在关闭频道之前发送的所有作业仍将被传递。
这将导致干净的设计，将导致固定（但任意）数量的goroutine，并且它将始终使用100％CPU（如果goroutines的＃大于CPU核心数）。它还具有以下优点：它可以被“节流”＃34;正确选择信道容量（缓冲信道）和消费者 goroutines的数量。
请注意，此模型具有指定的生产者goroutine不是强制性的。您可以有多个goroutine来生成作业，但是当所有生成器goroutine完成生成作业时，您必须同步它们以仅关闭jobs通道 - 否则尝试在jobs通道上发送另一个作业当它已经关闭时导致运行时恐慌。通常生产工作很便宜，并且可以比它们执行的速度快得多，所以这个模型用1 goroutine生产它们而许多人正在消耗/执行它们在实践中是好的。
处理结果：
如果作业有结果，您可以选择指定结果频道，在该频道上可以传送结果（＆＃34;发回＆＃34;），或者您可以选择处理结果当工作完成/完成时，在消费者中。后者甚至可以通过回调＆＃34;来实现。处理结果的函数。重要的是，结果是可以独立处理还是需要合并（例如map-reduce框架）或聚合。
如果你使用results频道，你还需要一个从中接收值的goroutine，防止消费者被阻止（如果results的缓冲区被填满就会发生。）
results频道不是将简单的string值作为作业和结果发送，而是创建一个包装类型，它可以保存任何其他信息，因此它更加灵活：
type Job struct {
Id int
Work string
Result string
}
请注意，Job结构也包含结果，因此当我们发回结果时，它还包含原始Job作为上下文 - 通常非常有用。另请注意，仅在频道上发送指针（*Job）而不是Job值是有利可图的，因此无需制作＆＃34;无数＆＃34; Job s的副本以及Job结构值的大小变得无关紧要。
以下是此生产者 - 消费者的样子：
我会使用2 sync.WaitGroup个值，他们的角色将遵循：
var wg, wg2 sync.WaitGroup
生产者负责生成要执行的工作：
func produce(jobs chan<- *Job) {
// Generate jobs:
id := 0
for c := 'a'; c <= 'z'; c++ {
id++
jobs <- &Job{Id: id, Work: fmt.Sprintf("%c", c)}
}
close(jobs)
}
完成后（没有更多工作），jobs频道关闭，向消费者发出信号，告知不再有工作到达。
请注意，produce()将jobs频道视为仅发送，因为生产者只需要执行此操作：发送< / em>上面的作业（除了关闭它，但仅发送频道也允许这样做）。生成器中的意外接收将是编译时错误（在编译时提前检测到）。
消费者的责任是只要收到工作就能接收工作并执行：
func consume(id int, jobs <-chan *Job, results chan<- *Job) {
defer wg.Done()
for job := range jobs {
sleepMs := rand.Intn(1000)
fmt.Printf("worker #%d received: '%s', sleep %dms\n", id, job.Work, sleepMs)
time.Sleep(time.Duration(sleepMs) * time.Millisecond)
job.Result = job.Work + fmt.Sprintf("-%dms", sleepMs)
results <- job
}
}
请注意，consume()会将jobs频道视为仅接收;消费者只需要接收。同样，results频道仅为消费者发送。
另请注意，results频道不能在这里关闭，因为有多个消费者goroutine，只有第一次试图关闭它会成功，而进一步会导致运行时恐慌！在所有消费者goroutine结束后，results频道可以（必须）关闭，因为我们可以确保在results频道上不会再发送任何其他值（结果）。
我们有需要分析的结果：
func analyze(results <-chan *Job) {
defer wg2.Done()
for job := range results {
fmt.Printf("result: %s\n", job.Result)
}
}
正如您所看到的，只要它们可能出现（直到results频道关闭），它也会收到结果。分析器的results频道仅接收。
请注意使用通道类型：只要它足够，在编译时只使用单向通道类型来及早发现并防止错误。如果您确实需要双向，请仅使用双向频道类型。
这就是所有这些粘在一起的方式：
func main() {
jobs := make(chan *Job, 100) // Buffered channel
results := make(chan *Job, 100) // Buffered channel
// Start consumers:
for i := 0; i < 5; i++ { // 5 consumers
wg.Add(1)
go consume(i, jobs, results)
}
// Start producing
go produce(jobs)
// Start analyzing:
wg2.Add(1)
go analyze(results)
wg.Wait() // Wait all consumers to finish processing jobs
// All jobs are processed, no more values will be sent on results:
close(results)
wg2.Wait() // Wait analyzer to analyze all results
}
示例输出：
以下是输出示例：
正如您所看到的，结果即将来临并在所有工作入队之前进行分析：
worker #4 received: 'e', sleep 81ms
worker #0 received: 'a', sleep 887ms
worker #1 received: 'b', sleep 847ms
worker #2 received: 'c', sleep 59ms
worker #3 received: 'd', sleep 81ms
worker #2 received: 'f', sleep 318ms
result: c-59ms
worker #4 received: 'g', sleep 425ms
result: e-81ms
worker #3 received: 'h', sleep 540ms
result: d-81ms
worker #2 received: 'i', sleep 456ms
result: f-318ms
worker #4 received: 'j', sleep 300ms
result: g-425ms
worker #3 received: 'k', sleep 694ms
result: h-540ms
worker #4 received: 'l', sleep 511ms
result: j-300ms
worker #2 received: 'm', sleep 162ms
result: i-456ms
worker #1 received: 'n', sleep 89ms
result: b-847ms
worker #0 received: 'o', sleep 728ms
result: a-887ms
worker #1 received: 'p', sleep 274ms
result: n-89ms
worker #2 received: 'q', sleep 211ms
result: m-162ms
worker #2 received: 'r', sleep 445ms
result: q-211ms
worker #1 received: 's', sleep 237ms
result: p-274ms
worker #3 received: 't', sleep 106ms
result: k-694ms
worker #4 received: 'u', sleep 495ms
result: l-511ms
worker #3 received: 'v', sleep 466ms
result: t-106ms
worker #1 received: 'w', sleep 528ms
result: s-237ms
worker #0 received: 'x', sleep 258ms
result: o-728ms
worker #2 received: 'y', sleep 47ms
result: r-445ms
worker #2 received: 'z', sleep 947ms
result: y-47ms
result: u-495ms
result: x-258ms
result: v-466ms
result: w-528ms
result: z-947ms
在Go Playground上尝试完整的应用程序。
results频道results频道，但消费者goroutines会立即处理结果（在我们的案例中打印），代码会大大简化。在这种情况下，我们不需要2 sync.WaitGroup个值（只需要等待分析仪完成第二个）。
没有results频道，完整的解决方案如下：
var wg sync.WaitGroup
type Job struct {
Id int
Work string
}
func produce(jobs chan<- *Job) {
// Generate jobs:
id := 0
for c := 'a'; c <= 'z'; c++ {
id++
jobs <- &Job{Id: id, Work: fmt.Sprintf("%c", c)}
}
close(jobs)
}
func consume(id int, jobs <-chan *Job) {
defer wg.Done()
for job := range jobs {
sleepMs := rand.Intn(1000)
fmt.Printf("worker #%d received: '%s', sleep %dms\n", id, job.Work, sleepMs)
time.Sleep(time.Duration(sleepMs) * time.Millisecond)
fmt.Printf("result: %s\n", job.Work+fmt.Sprintf("-%dms", sleepMs))
}
}
func main() {
jobs := make(chan *Job, 100) // Buffered channel
// Start consumers:
for i := 0; i < 5; i++ { // 5 consumers
wg.Add(1)
go consume(i, jobs)
}
// Start producing
go produce(jobs)
wg.Wait() // Wait all consumers to finish processing jobs
}
输出是＆＃34;喜欢＆＃34;使用results频道的频道（但当然执行/完成顺序是随机的）。
在Go Playground上尝试此变体。
答案 1 :(得分：2)
您可以实现计数信号量来限制goroutine并发。
var tokens = make(chan struct{}, 20)
func worker(id string, work string, o chan string, wg *sync.WaitGroup) {
defer wg.Done()
tokens <- struct{}{} // acquire a token before performing work
sleepMs := rand.Intn(1000)
fmt.Printf("worker '%s' received: '%s', sleep %dms\n", id, work, sleepMs)
time.Sleep(time.Duration(sleepMs) * time.Millisecond)
<-tokens // release the token
o <- work + fmt.Sprintf("-%dms", sleepMs)
}
这是用于限制工人数量的一般设计。您当然可以更改令牌的发布/获取位置以适合您的代码。