Buffered Channels and Worker Pools-优快云博客

本文深入探讨了Go语言中的并发模式，包括带缓冲的通道如何在达到缓冲限制时阻止进程，以及如何利用sync.WaitGroup来同步多个goroutine的完成状态。通过具体的代码示例介绍了工作池的实现方式，展示了如何分配任务并收集结果。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

原文链接:https://golangbot.com/buffered-channels-worker-pools/

buffered channels

带有缓冲区的channel 只有在缓冲区满之后 channel才会阻塞

WaitGroup

如果有多个 goroutine在后台执行那么需要在主线程中多次等待可以有一个简单的方法就是通过WaitGroup 可以控制 Goroutines 直到它们都执行完成

例子

import (  
    "fmt"
    "sync"
    "time"
)

func process(i int, wg *sync.WaitGroup) {  
    fmt.Println("started Goroutine ", i)
    time.Sleep(2 * time.Second)
    fmt.Printf("Goroutine %d ended\n", i)
    wg.Done()
}

func main() {  
    no := 3
    var wg sync.WaitGroup
    for i := 0; i < no; i++ {
        wg.Add(1)
        go process(i, &wg)
    }
    wg.Wait()![](https://images2018.cnblogs.com/blog/736597/201803/736597-20180312115109926-1714494090.png)


    fmt.Println("All go routines finished executing")
}

Worker Pool Implementation

先贴一下个人理解的程序执行的流程图

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

type Job struct {
    id       int
    randomno int
}
type Result struct {
    job         Job
    sumofdigits int
}

var jobs = make(chan Job, 10)
var results = make(chan Result, 10)

func digits(number int) int {
    sum := 0
    no := number
    for no != 0 {
        digit := no % 10
        sum += digit
        no /= 10
    }
    time.Sleep(5 * time.Second)
    return sum
}
func worker(wg *sync.WaitGroup) {
    for job := range jobs {
        output := Result{job, digits(job.randomno)}
        results <- output
    }
    wg.Done()
}
func createWorkerPool(noOfWorkers int) {
    var wg sync.WaitGroup
    for i := 0; i < noOfWorkers; i++ {
        wg.Add(1)
        go worker(&wg)
    }
    wg.Wait()
    close(results)
}
func allocate(noOfJobs int) {
    for i := 0; i < noOfJobs; i++ {
        randomno := rand.Intn(999)
        job := Job{i, randomno}
        jobs <- job
    }
    close(jobs)
}
func result(done chan bool) {
    for result := range results {
        fmt.Printf("Job id %d, input random no %d , sum of digits %d\n", result.job.id, result.job.randomno, result.sumofdigits)
    }
    done <- true
}

func main() {
    startTime := time.Now()

    noOfJobs := 100
    go allocate(noOfJobs)

    done := make(chan bool)
    go result(done)
    noOfWorkers := 10
    createWorkerPool(noOfWorkers)
    <-done

    endTime := time.Now()


    diff := endTime.Sub(startTime)
    fmt.Println("total time taken ", diff.Seconds(), "seconds")
}

转载于:https://www.cnblogs.com/alin-qu/p/8548512.html