Multithreading 这是Go中惯用的工作线程池吗？

我正试图用goroutines编写一个简单的工作池

• 我写的代码是惯用的吗？如果没有，那么应该改变什么
• 我希望能够将工作线程的最大数量设置为5，并阻止，直到一个工作线程变得可用（如果所有5个线程都忙）。我如何将此扩展到最多只有5名员工？我是否生成静态5个goroutine，并为每个goroutine分配

  工作\u通道

代码：

主程序包
进口(
“fmt”
“数学/兰德”
“同步”
“时间”
)
func worker（id字符串、工作字符串、o chan字符串、wg*sync.WaitGroup）{
推迟工作组完成（）
sleepMs:=rand.Intn（1000）
fmt.Printf（“接收到工作'%s'：'%s'，睡眠%dms\n'，id，工作，睡眠ms）
时间.睡眠（时间.持续时间（sleepMs）*时间.毫秒）
o可以实现计数信号量来限制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)
}

var-tokens=make（chan-struct{}，20）
func worker（id字符串、工作字符串、o chan字符串、wg*sync.WaitGroup）{
推迟工作组完成（）
令牌您的解决方案在任何意义上都不是工作goroutine池：您的代码不限制并发goroutine，也不“重用”goroutine（当接收到新作业时，它总是启动一个新的goroutine）

生产者-消费者模式
如发布于，您可以使用。您可以指定一个生产者goroutine来生成作业（要做的事情/计算），并将其发送到作业频道。您可以有一个固定的消费者goroutine池（例如，其中5个）它将在传递作业的通道上循环，每个通道都将执行/完成接收到的作业

当生成并发送所有作业时，producer goroutine可以简单地关闭
作业
通道，正确地向消费者发出不再有作业的信号。通道上的
for…range
构造处理“关闭”事件并正确终止。请注意，在关闭通道之前发送的所有作业仍将被传递

这将导致一个干净的设计，将导致固定（但任意）数量的goroutine，并且它将始终使用100%的CPU（如果goroutine的#大于CPU核的#）。它还有一个优点，即可以通过正确选择通道容量（缓冲通道）来“节流”以及消费者goroutine的数量

请注意，此模型不强制要求有指定的生产者goroutine。您也可以有多个goroutine来生成作业，但是您也必须同步它们，以便在所有生产者goroutine都已生成作业时仅关闭
作业
通道，否则在它已经关闭，导致运行时恐慌。通常生产作业的成本很低，而且生产速度比执行速度快得多，因此，这种在1个goroutine中生产作业的模式在实践中是很好的，因为许多人都在消费/执行作业

处理结果：

如果作业有结果，您可以选择使用指定的结果通道来传递结果（“发送回”），也可以选择在作业完成/完成时在使用者中处理结果。后者甚至可以通过“回调”来实现处理结果的函数。重要的是结果是可以独立处理还是需要合并（例如map reduce framework）或聚合

如果使用
results
频道，还需要一个goroutine来接收来自它的值，防止消费者被阻塞（如果
results
的缓冲区被填满，就会发生这种情况）

使用
结果
频道
与发送简单的
string
值作为作业和结果不同，我将创建一个包装器类型，它可以保存任何其他信息，因此更加灵活：

type Job struct {
    Id     int
    Work   string
    Result string
}

请注意，
作业
结构也包装了结果，因此当我们返回结果时，它还包含原始的
作业
作为上下文-通常非常有用。还请注意，只在通道上发送指针（
*作业
）而不是
作业
值是有益的，因此无需进行“无数”运算
作业
s的副本，以及
作业
结构值的大小变得无关

以下是生产者-消费者的样子：

我将使用2个值，它们的作用如下：

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

请注意，
consume（）
将
jobs
频道视为仅接收；消费者只需要从中接收。类似地，
results
频道仅为消费者发送

还请注意，
results
channel无法在此处关闭，因为存在多个使用者goroutine，并且只有第一次尝试关闭它才会成功，进一步尝试将导致运行时死机！
results
channel可以（必须）在所有消费者goroutine结束后关闭，因为这样我们可以确保在
results
频道上不会发送更多的值（结果）

我们有需要分析的结果：

func analyze(results <-chan *Job) {
    defer wg2.Done()
    for job := range results {
        fmt.Printf("result: %s\n", job.Result)
    }
}

示例输出：

以下是一个示例输出：

如您所见，在所有作业进入队列之前，结果会出现并得到分析：

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

在上尝试完整的应用程序

没有
结果
频道
如果我们不使用results通道，但消费者goroutines会立即处理结果（在我们的案例中打印出来），那么代码将大大简化。在这种情况下，我们不需要2个sync.WaitGroup值（第2个值只需要等待分析器完成）

如果没有
结果
通道，完整的解决方案如下：

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
}

var wg sync.WaitGroup
类型作业结构{
Id int
工作串
}
func product（参见
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

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
}