限制并发量

源码

今天调试了一下golang编译工具，发现了一个很有"奇怪"的地方

简化问题

假设有1000个任务，1000个并发协程，设置n（cpu核数）个物理处理器（task）并发完成，每个协程只要完成了当前任务采取完成下一个

代码

原始代码，go作者无所畏惧的使用协程

func parseFiles(filenames []string) uint {  
    var noders []*noder
    // Limit the number of simultaneously open files.
    sem := make(chan struct{}, runtime.GOMAXPROCS(0)+10)

    for _, filename := range filenames {
        go func(filename string) {
            sem <- struct{}{}
            defer func() { <-sem }()
                        ... 
        }(filename)
    }

针对问题代码

package main

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

func main() {

    c := make(chan os.Signal)
    signal.Notify(c, os.Interrupt)

    rand.Seed(time.Now().UnixNano())
    task := make([]func(), 1000)
    for i := 0; i < 1000; i++ {
        task[i] = func() {
            r := rand.Intn(100)
            time.Sleep(time.Duration(r) * time.Millisecond)
            fmt.Printf("Task cost %d\n", r)
        }
    }

    sem := make(chan struct{}, runtime.GOMAXPROCS(0)+10)

    for i := 0; i < len(task); i++ {
        f := task[i]
        go func(f func()) {
            sem <- struct{}{}
            defer func() { <-sem }()
            f()
        }(f)
    }

    <-c
}

如果控制10个协程，应该怎么写呢

package main

import (  
    "fmt"
    "math/rand"
    "os"
    "os/signal"
    "runtime"
    "sync"
    "time"
)

func main() {  
    c := make(chan os.Signal)
    signal.Notify(c, os.Interrupt)
    exit := make(chan bool)

    sem := make(chan func(), runtime.GOMAXPROCS(0))
    task := make([]func(), 1000, 1000)

    rand.Seed(time.Now().UnixNano())
    for i := 0; i < len(task); i++ {
        task[i] = func() {
            r := rand.Intn(100)
            time.Sleep(time.Duration(r) * time.Millisecond)
            fmt.Printf("task cost %d\n", r)
        }
    }

    wg := &sync.WaitGroup{}
    for i := 0; i < runtime.GOMAXPROCS(0); i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for {
                select {
                case f := <-sem:
                    f()
                case <-exit:
                    fmt.Printf("Gracefully exit....\n")
                    return
                }
            }
        }()
    }

    go func() {
        for i := 0; i < len(task); i++ {
            sem <- task[i]
        }
    }()

    <-c
    close(exit)
    wg.Wait()
}