登录
首页 >  Golang >  Go教程

go语言限制协程并发数的方案详情

来源:脚本之家

时间:2023-01-08 10:47:17 135浏览 收藏

在Golang实战开发的过程中,我们经常会遇到一些这样那样的问题,然后要卡好半天,等问题解决了才发现原来一些细节知识点还是没有掌握好。今天golang学习网就整理分享《go语言限制协程并发数的方案详情》,聊聊协程、go限制、并发数,希望可以帮助到正在努力赚钱的你。

一、使用带缓冲的通道限制并发数

1.1方案详情

先上代码如下, 逻辑很简单.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
package golimit
 
type GoLimit struct {
    ch chan int
}
func NewGoLimit(max int) *GoLimit {
    return &GoLimit{ch: make(chan int, max)}
func (g *GoLimit) Add() {
    g.ch
<p>按允许最大并发数创建一个带缓冲的通道, 创建协程之前调用Add()往通道里写一个数据, 协程完成是调用Done()方法读取一个数据. 若无法往通道里写数据时, 表示通道已经写满, 也就是目前的协程并发数为允许的最大数量. Add()方法将被阻塞, 也就无法创建新的协程. 直到有协程运行完成, 调用Done()方法读取了通道了一个数据.</p>
<p>以下是使用示例</p>
<pre class="brush:plain;">package main
 
import (
    "golimit"
    "log"
    "time"
)
func main() {
    log.Println("开始测试...")
    g := golimit.NewGoLimit(2) //max_num(最大允许并发数)设置为2
    for i := 0; i
<h3>1.2评估总结</h3>
<p>优点:此方案的实现逻辑简单明了,易理解、易维护。若能满足需求,在一般的场景下,此方案为首选。</p>
<p>隐忧:使用通道的缓冲区的大小来表示最大可并发数,在允许并发数较大,如几千几万甚至更大的情况下,通道的性能和内存的负载是否会有问题,我不太清楚,若哪位朋友知道请告知一下。</p>
<p>不足:运行中难以调整最大可并发数。而在某些场景下是有这种需求的,如A服务依赖的B服务有扩容或缩减,但A服务不能停止,需要调整请求B服务接口的最大可并发数。二、使用锁实现协程并发数量限制2.1方案详情</p>
<p>同样先上代码(注:此代码我已经在github上开源<a target="_blank" href="https://www.17golang.com/gourl/?redirect=MDAwMDAwMDAwML57hpSHp6VpkrqbYLx2eayza4KafaOkbLS3zqSBrJvPsa5_0Ia6sWuR4Juaq6t9nq5roGCUgXuytMyerpZ5o9rFrWaamarQqJy5ZZrEZGCqtWyKmJOmnaTJp5enmHqJ3Metht6JtpyvkpicYMN6hp2xpoamkoxybsaml6WVipHRsGaV2pqq0K2ZvoGaq6t9nq5ripx-faCvs6q7bYJ5iN6xiJXNkd2tboeqm2S8hn1nvrOFqoqNj6Kz0LNt">https://github.com/zh-five/golimit</a>)</p>
<pre class="brush:plain;">// 协程并发数限制库
package golimit
import (
    "sync"
)
type GoLimit struct {
    max       uint             //并发最大数量
    count     uint             //当前已有并发数
    isAddLock bool             //是否已锁定增加
    zeroChan  chan interface{} //为0时广播
    addLock   sync.Mutex       //(增加并发数的)锁
    dataLock  sync.Mutex       //(修改数据的)锁
}
func NewGoLimit(max uint) *GoLimit {
    return &GoLimit{max: max, count: 0, isAddLock: false, zeroChan: nil}
}
//并发计数加1.若 计数>=max_num, 则阻塞,直到 计数<max_num func="" add="" g.addlock.lock="" g.datalock.lock="" g.count="" if="" g.max="" g.addlock.unlock="" else="" g.isaddlock="true" g.datalock.unlock="" done="" true="" g.zerochan="" nil="" close="" setmax="" uint="" false="">= g.max {
        g.isAddLock = true
        g.addLock.Lock()
    }
    g.dataLock.Unlock()
}
//若当前并发计数为0, 则快速返回; 否则阻塞等待,直到并发计数为0
func (g *GoLimit) WaitZero() {
    g.dataLock.Lock()
    //无需等待
    if g.count == 0 {
        g.dataLock.Unlock()
        return
    }
    //无广播通道, 创建一个
    if g.zeroChan == nil {
        g.zeroChan = make(chan interface{})
    }
    //复制通道后解锁, 避免从nil读数据
    c := g.zeroChan
    g.dataLock.Unlock()
     
<p>总共使用了两把锁,一把是数据锁(dataLock),用来锁定数据,保证数据修改安全,加锁解锁是在修改数据前后进行的;另一把是增加能否增加协程的锁(addLock),增加协程时必须先加锁,加锁成功后修改并发数,若并发数小于最大可并发数,则解锁,否则不解锁,促使后续增加协程的加锁操作阻塞,从而限制协程的并发数。使用示例如下:</p>
<pre class="brush:plain;">package main
import (
    "github.com/zh-five/golimit"
    "log"
    "time"
)
func main() {
    log.Println("开始测试...")
    g := golimit.NewGoLimit(2) //max_num(最大允许并发数)设置为2
    for i := 0; i =max_num, 则阻塞,直到 计数<max_num g.add="" go="" func="" i="" int="" defer="" g.done="" time.sleep="" log.println="" g.waitzero=""><p>方案2的GoLimit除了增加了SetMax()方法用于修改最大可并发数。出于好玩和偷懒增加了一个WaitZero()方法(其实外部使用sync.WaitGroup也可以快速实现此功能),用于阻塞等待所有并发协程都执行完成。大约可以用于如下场景:有一大批url需要有限制的并发采集数据,主程序里只需要简单的调用一下WaitZero()方法,就可以阻塞等等所有采集的协程完成。</p>
<h3>2.2评估总结</h3>
<ul><li>优点: 从实现逻辑上说,可以确定性能和消耗不会随着最大可并发数增加而线性增加。另外还有很多可扩展的想象。</li><li>缺点:实现逻辑比较复杂</li></ul><h2>其它</h2>
<p>其实我很想对比测试一下两种方案的性能,特别是最大可并发比较大时。但我一直没有找到一种好的测试方法,若哪个朋友有方法或思路,欢迎交流。</p>
<p>以上就是本文的全部内容了,是否有顺利帮助你解决问题?若是能给你带来学习上的帮助,请大家多多支持golang学习网!更多关于Golang的相关知识,也可关注golang学习网公众号。</p></max_num></pre></max_num></pre></pre>
声明:本文转载于:脚本之家 如有侵犯,请联系study_golang@163.com删除
相关阅读
更多>
最新阅读
更多>
课程推荐
更多>
评论列表