如何设置最大并发 goroutine 数量以提高工作效率？

怎么入门Golang编程？需要学习哪些知识点？这是新手们刚接触编程时常见的问题；下面golang学习网就来给大家整理分享一些知识点，希望能够给初学者一些帮助。本篇文章就来介绍《如何设置最大并发 goroutine 数量以提高工作效率？》，涉及到，有需要的可以收藏一下

var wg sync.WaitGroup
wg.Add(len(work))

sem := make(chan struct{}, 10)

wgDone := make(chan bool)

for i < len(work)-1 {
    go func() {
        defer wg.Done()
        sem <- struct{}{}
        defer func() {
            <-sem
        }()
        worker(work[i])
    }()
    i = i + 1
}

go func() {     
    wg.Wait()
    close(wgDone)
}()

我一次只需要 10 个新 goroutine 来执行工作。这是我当前的解决方案，它阻止 goroutine 继续运行，因此一次只有 10 个。我怎样才能改变这个，这样它就不会创建大量被阻塞等待工作的 goroutine，而是只创建 10 个完成所有工作的 goroutine？

解决方案

根据用例，以下方法之一很有用：

1. 使用 max 个新 goroutine 和一个通道作为队列 (The Go playground)：

package main

import (
    "fmt"
    "sync"
)

func main() {
    const max = 10
    queue := make(chan int, max)
    wg := &sync.waitgroup{}
    for i := 0; i < max; i++ {
        wg.add(1)
        go worker(wg, queue)
    }
    for i := 0; i < 100; i++ {
        queue <- i
    }
    close(queue)
    wg.wait()
    fmt.println("done")
}
func worker(wg *sync.waitgroup, queue chan int) {
    defer wg.done()
    for job := range queue {
        fmt.print(job, " ") // a job
    }
}

1. 使用缓冲通道作为信号量来限制新协程数量为最大数量（The Go playground）：

package main

import (
    "fmt"
    "sync"
)

func main() {
    const max = 10
    semaphore := make(chan struct{}, max)
    wg := &sync.waitgroup{}
    for i := 0; i < 1000; i++ {
        semaphore <- struct{}{} // acquire
        wg.add(1)
        go limited(i, wg, semaphore)
    }
    wg.wait()
    fmt.println("done")
}
func limited(i int, wg *sync.waitgroup, semaphore chan struct{}) {
    defer wg.done()
    fmt.println("i =", i) // a job
    <-semaphore // release
}

1. 使用缓冲通道作为信号量来限制作业数量为最大数量 - 这里 goroutine 的数量超过了最大数量 (The Go playground)：李>

package main

import (
    "fmt"
    "sync"
)

func main() {
    const max = 10
    semaphore := make(chan struct{}, max)
    wg := &sync.WaitGroup{}
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go limited(i, wg, semaphore)
    }
    wg.Wait()
    fmt.Println("Done")
}
func limited(i int, wg *sync.WaitGroup, semaphore chan struct{}) {
    defer wg.Done()
    semaphore <- struct{}{} // acquire
    fmt.Println("i =", i) // a job
    <-semaphore // release
}

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《如何设置最大并发 goroutine 数量以提高工作效率？》文章吧，也可关注golang学习网公众号了解相关技术文章。