Golang Go语言中求并发限制的最佳实现
Golang Go语言中求并发限制的最佳实现
情况如下： 有 N 个任务，每个任务执行完都会返回结果或者 error，通过固定的(M)协程去执行，如果其中有一个任务返回 error 时立即结束，否则全部执行完成时返回结果列表。
我自己写了一版，感觉有点复杂：https://play.golang.org/p/ono1S04XupK
不知道各位有没有什么更简单的实现。
更多关于Golang Go语言中求并发限制的最佳实现的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html
一个 err chan 用来通知 root goroutine 发生错误，然后 root context 退出； wait group 用来做全部完成检查。
这样何如？
一个比较简单的实现
https://play.golang.org/p/MDU_x7C2npI
如果有一个 routine 有 error，ctx 会 Done
如果 ctx 已经 Done 了，semaphore 会 error
#23 这个好像也有点问题哦，就是判断任务全部执行完成的地方<br>if i == n-1 {<br> close(doneCh)<br>}<br>
这里判断最后一个任务执行完成就结束，但是可能会存在还有正在执行的任务并且比最后一个任务执行还慢，就不对了。
你仔细看一下打出来的内容，第一批开始执行的任务里没有 1 （ 1 没有抢到信号量）。当 1 抢到信号量开始执行后整个程序都结束了（其他的任务都取消了，不然如果 i 那个循环大的话整个程序会运行很久）
- 声明一个 buffered chan 当做 goroutine 池子 。
2. 启动 goroutine 的时候传入 context 用做取消（前提是你的 goroutine 任务可以取消）。
#27 错误发生时不会立刻结束，而是会等正在执行的任务全部完成才返回，你可以跑这个试试： https://play.golang.org/p/66Me2TYbVoK
错误发生了也要等 5 秒才结束。
我觉得这是个很好的面试题，既有实际意义也考验基本功，大家可以试试不用三方库实现一下~
talk is cheap, show me the code
一起娱乐娱乐，新年快乐~！
1. 控制并发
2. 等待所有任务返回
3. 一个任务错误，立刻结束
如果不解耦，并发控制和结果处理的逻辑混杂确实屎
go 实现的时候想当然了，只以最后提交的任务判断是否结束
kotlin 协程实现的时候发现 io，计算任务无法退出，必须要手动捕捉中止信号
java 须要手动捕捉中止信号 但是可以通过 thread.stop()强制停止，另外判断线程是否异常退出较难
最开始的版本里注释有写 DoWork 里的操作需要支持 context cancellation (比如如果操作是 http.Get 的话，可以使用 http.NewRequestWithContext)
这个里面实现了一个如果调用的操作不支持 context cancellation 的情况
https://play.golang.org/p/Cot1FYgIKLd
#35 实际上很多 work 是不支持 cancel 的，而且也不一定要 cancel 掉，只要不阻塞主协程就行了，发送错误的时候主协程继续执行，其它正在执行的任务让它继续跑。
难道 slice+context.Context+errgroup 的组合不行？
1.分配 M 容量的 slice 。放 M 个 go 程正常运行的结果。每个 go 程都有自己的 index，所以存结果这块都不要加锁，相当舒服的操作。
2.context 当作异常终端点。每个 go 程都持有这个 context 变量。任意一个 go 程错误,cancel 。任意 go 程检查 ctx.Done()。所谓 “如果其中有一个任务返回 error 时立即结束” 完美实现。
3.检查 errgroup 的返回，err != nil，就返回错误，else 部分没有错误，返回第 1 步声明的 slice
分解问题：
1. 通过固定的 M 个携程执行。
解决方案：信号量或者条件变量或者 channel，很多种方法实现。
2. 只要出现一个任务返回 Error，就立即结束全部任务。
解决方案：C#的 TAP 的 Task.WhenAny 和 CancellationToken 模式可以很好的解决这些问题。
那么只需要用 go 来实现 Task.WhenAny 和 CancellationToken 模式即可。
CancellationToken 很好实现，用 struct {IsCancellationRequired: bool}就可以实现。
Task.WhenAny 可以用如下方式实现：有一个 chan ch，每个任务完成后，往 ch 里面写一个数字（或者写入任务信息），同时主线程阻塞读取 ch 。
//放结果伪代码
// 每个 go 程的 id 已经固定下来，就是 for 循环启动的 index.大家操作自己的私有 index 。为啥会有竞争？
for i :=0;i < M;i++ {
i:=i
go func(){
slice[i] = result
}
}
N 个的容量的 success channel.
再来一个 err channel
然后主线程那里 select 这两个 channel 做事情就可以啦.
----------------------
至于你纠结 err 之后协程能不能关闭, 那个不是你关心的事情了. 可以考虑传递一个 context 给 request, err 发生错误的时候进行 cancel context 即可.
https://play.golang.org/p/YYvynelzIHj
感兴趣写了下，如果想出现错误后中断其他 goroutine 的处理，其他 goroutine 必须可以被 cancel 掉。
并发限制用协程池，退出机制需要自己实现。
如果懒得实现，就直接摘出来，用系统的实现。main 启动之后开一个协程监听退出信号，收到退出信号之后直接 os.Exit()
其实还是应该自己在代码中实现出来，那个操作只能玩玩。看看源码，用 runtime.Goexit() 来终止协程。
errgroup context 都是用来传递消息的，并不是来做终止的。你用这两个来做的话，只能每进行一步就检查一下是否有退出信号，不然就做不到及时退出。
#49 你好，请教一下，在 61 行的这一部分，为什么两个 channel 之间互相要写数据？<br> select {<br> case err := <-errCh:<br> handleErr(err, result[1:])<br> <-done<br> case <-done:<br> if len(errCh) > 0 {<br> err := <-errCh<br> handleErr(err, result[1:])<br> return<br> }<br> fmt.Println("success handle all task:", result[1:])<br> }<br>
改成这样是否可以？<br> select {<br> case err := <-errCh:<br> handleErr(err, result[1:])<br> case <-done:<br> fmt.Println("success handle all task:", result[1:])<br> }<br>
没有相互写数据，是为了一些健壮性考虑吧。第一个 case 如果从 errCh 中读到 err 了，<-done 表示等待其他 goroutine 也都结束，是怕有 goroutine 泄露。第二个 case 是考虑可能有极小概率 errCh 和 done 同时有数据，select 随机选择了 done channel，所以最终再判断下 errCh 是否有 err 。
#54 “相互写数据”这个表述不太严谨。不过你说的有道理，从健壮性来说，确实需要考虑这些极端情况。
#55 个人觉得 35L 的写法确实比较优雅，但是从效率来说，还是 49L 的写法更好一些，因为 49L 的协程数量是 M 个，而 35L 的协程数量是 N 个，当 N>>M 时，虽然 golang 的协程足够轻量，但是也没必要这么浪费。
在Golang中，实现并发限制的最佳实践通常是使用Go的内置工具，如goroutines和通道（channels），以及结合使用sync.WaitGroup或context包来管理并发任务的生命周期。
一个常见的模式是使用带缓冲区的通道作为信号量来控制同时运行的goroutine数量。你可以创建一个带N个缓冲区的通道，其中N是你希望同时运行的最大goroutine数量。每个goroutine在开始执行前，会从通道中获取一个空位（即发送一个空值到通道），执行完毕后释放这个空位（即从通道中接收一个值）。
示例代码如下：
func main() {
maxWorkers := 5 // 并发限制
jobs := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
sem := make(chan struct{}, maxWorkers)
var wg sync.WaitGroup
for _, job := range jobs {
wg.Add(1)
sem <- struct{}{} // 获取一个空位
go func(j int) {
defer wg.Done()
defer func() { <-sem }() // 释放空位
// 执行工作
fmt.Println("Processing job", j)
}(job)
}
wg.Wait()
}
这种方法简单且高效，能有效控制并发量，防止因创建过多goroutine而导致的资源耗尽问题。同时，结合sync.WaitGroup可以确保所有任务完成后程序才退出，非常适合处理大量并发任务但希望限制并发数的场景。
