代码之家 › 专栏 › 技术社区 › cactus

如何设置完成工作的最大goroutines数?

goroutine go

cactus · 技术社区 · 5 年前

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个新goroutines

1 回复 | 直到 5 年前

Shubham Srivastava 5 年前

所以如果你只想说10个工人,你应该产生10个工人听一个作业队列,这可以是一个通道,你可以把输入推到这个通道,工人将选择它

现在它只会在队列已满时阻塞作业,这样您就可以根据您的用例来决定队列大小

package main

import (
    "fmt"
    "sync"
)

var jobQ chan int
var wg sync.WaitGroup

func main() {
    jobQ = make(chan int, 100)
    
    go func(){
        wg.Add(1)
        defer wg.Done() 
        //Spawn 10 workers
        for i:=0;i<10;i++ {
            fmt.Println("Spawn :", i)
            wg.Add(1)
            go worker(jobQ)
            wg.Done()
        }
    }()
    
    for i := 0; i< 1000;i++ {
        jobQ<- i
    }
    close(jobQ)
    
    
    wg.Wait()
}



func worker(jobs chan int) {
    for job:=range jobs {
        fmt.Println(job)
    }
}

游乐场: https://play.golang.org/p/lzIMRUCvqR9

wasmup Prog_is_life 5 年前

根据用例,以下方法之一是有用的:

使用 max 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
    }
}

使用缓冲通道作为信号量这个 新goroutines数 最大值 数量( 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
}

使用缓冲通道作为信号量限制数量 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
}