Concurrency Golang：生产者/消费者并发模型，但具有序列化结果 func main（）{ 作业：=[]作业{job1，job2，job3} numOfJobs:=len（作业） 结果chan:=make（chan*Result，numOfJobs） jobChan:=制造（chan*job，numOfJobs） 去消费（numOfJobs、jobChan、resultsChan） 对于i:=0；i

以下是我处理序列化的一种方法（并设置了有限数量的工作人员）。我使用输入和输出字段以及同步通道设置了一些worker对象，然后对它们进行循环，提取它们所做的任何工作并给它们一个新的作业。然后我对它们进行最后一次遍历，以提取剩余的任何已完成作业。请注意，您可能希望worker计数稍微超过您的核心计数，因此即使有一个异常长的作业，您也可以让所有资源忙碌一段时间

这很复杂（比我坐下来写一个例子之前记得的要复杂！）——我很想看看其他人有什么，或者是更好的实现，或者是一种完全不同的方式来实现你的目标

func main() {
    jobs := []Job{job1, job2, job3}
    numOfJobs := len(jobs)
    resultsChan := make(chan *Result, numOfJobs)
    jobChan := make(chan *job, numOfJobs)
    go consume(numOfJobs, jobChan, resultsChan)
    for i := 0; i < numOfJobs; i++ {
        jobChan <- jobs[i]
    }
    close(jobChan)

    for i := 0; i < numOfJobs; i++ {
        <-resultsChan
    }
    close(resultsChan)
}

func (b *Blockchain) consume(num int, jobChan chan *Job, resultsChan chan *Result) {
    for i := 0; i < num; i++ {
        go func() {
            job := <-jobChan
            resultsChan <- doJob(job)
        }()
    }
}

主程序包
进口(
“fmt”
“数学/兰德”
“运行时”
“时间”
)
类型工作结构{
整数
out int
初始布尔
陈波
陈波先生
}
func（w*工人）工作（）{
time.Sleep（time.Duration（rand.Float32（）*Float32（time.Second）））
w、 out=w.in+1000
}
func（w*工作者）监听（）{
因为这可能是重复的，请检查此链接：嘿，Yasir，谢谢你。但是，我不认为这是重复的。因为你指出的问题似乎没有解决线性化/序列化结果。
package main

import (
    "fmt"
    "math/rand"
    "runtime"
    "time"
)

type Worker struct {
    in     int
    out    int
    inited bool

    jobReady chan bool
    done     chan bool
}

func (w *Worker) work() {
    time.Sleep(time.Duration(rand.Float32() * float32(time.Second)))
    w.out = w.in + 1000
}
func (w *Worker) listen() {
    for <-w.jobReady {
        w.work()
        w.done <- true
    }
}
func doSerialJobs(in chan int, out chan int) {
    concurrency := 23
    workers := make([]Worker, concurrency)
    i := 0
    // feed in and get out items
    for workItem := range in {
        w := &workers[i%
            concurrency]
        if w.inited {
            <-w.done
            out <- w.out
        } else {
            w.jobReady = make(chan bool)
            w.done = make(chan bool)
            w.inited = true
            go w.listen()
        }
        w.in = workItem
        w.jobReady <- true
        i++
    }
    // get out any job results left over after we ran out of input
    for n := 0; n < concurrency; n++ {
        w := &workers[i%concurrency]
        if w.inited {
            <-w.done
            out <- w.out
        }
        close(w.jobReady)
        i++
    }
    close(out)
}
func main() {
    runtime.GOMAXPROCS(10)
    in, out := make(chan int), make(chan int)
    allFinished := make(chan bool)
    go doSerialJobs(in, out)
    go func() {
        for result := range out {
            fmt.Println(result)
        }
        allFinished <- true
    }()
    for i := 0; i < 100; i++ {
        in <- i
    }
    close(in)
    <-allFinished
}