[Go] golang缓冲通道实现管理一组goroutine工作

通道
1.当一个资源需要在goroutine之间共享时,通道在goroutine之间架起了一个管道
2.无缓冲通道和有缓冲通道,make的第二个参数就是缓冲区大小
3.无缓冲通道需要发送和接收都准备好,否则先执行的goroutine会阻塞等待
4.有缓冲的通道,在缓冲区没满之前,发送和接收动作都不会阻塞,空的时候接收才会阻塞

time.Now().Unix() 当前时间戳 time.Millisecond 毫秒
time.Sleep(1 * time.Second) 睡眠一秒

package main
 
import (
    "fmt"
    "math/rand"
    "sync"
    "time"
)
 
const (
    //全局常量
    numberGoroutines = 4  //使用goroutine的数量
    taskLoad         = 10 //要处理的工作量
)
 
var wg sync.WaitGroup
 
//init函数会在main之前执行
func init() {
    //初始化随机数
    rand.Seed(time.Now().Unix())
}
func main() {
    //创建有缓冲的通道管理,缓冲区是10
    tasks := make(chan string, taskLoad)
 
    //启动4个goroutines来处理工作
    wg.Add(numberGoroutines) //加入计数信号量
    for i := 1; i <= numberGoroutines; i++ {
        go worker(tasks, i)
    }
 
    //主goroutine将10个字符串发送到通道,模拟分发给子goroutine的工作
    for j := 1; j <= taskLoad; j++ {
        tasks <- fmt.Sprintf("Task: %d", j)
    }
    //发送完成后,把通道关闭
    close(tasks)
    //如果一直往通道塞,子goroutine就可以一直工作,可以当队列用
    // for {
    //  tasks <- fmt.Sprintf("Task: %d", rand.Int63n(10000000000))
    // }
 
    //等待所有goroutines完成
    wg.Wait()
}
 
//处理工作
func worker(tasks chan string, worker int) {
    defer wg.Done()
    //无限循环处理接收到的工作,可以处理完一个以后继续处理下一个
    for {
        //从已经关闭的通道中,依然可以接收数据,并且返回一个通道类型的零值,如果一个都没接收到的时候会阻塞
        //接收到一个以后,会继续往下执行
        task, ok := <-tasks
        //判断通道是否清空并关闭
        if !ok {
            fmt.Printf("Worker: %d:关闭\n", worker)
            //直接退出这个goroutine
            return
        }
        //正式开始工作
        fmt.Printf("Worker: %d:开始工作\n", worker)
        //用随机睡眠来模拟执行中
        sleep := rand.Int63n(100)
        time.Sleep(time.Duration(sleep) * time.Millisecond)
        //显示完成了
        fmt.Printf("Worker: %d :完成 %s \n", worker, task)
    }
}