golang并发编程的两种限速方法
本文内容纲要：
-引子
-方案一
-实现
-测试
-方案二
-实现
-测试
-改造
引子
golang提供了goroutine快速实现并发编程，在实际环境中，如果goroutine中的代码要消耗大量资源时（CPU、内存、带宽等），我们就需要对程序限速，以防止goroutine将资源耗尽。
以下面伪代码为例，看看goroutine如何拖垮一台DB。假设userList长度为10000，先从数据库中查询userList中的user是否在数据库中存在，存在则忽略，不存在则创建。
//不使用goroutine，程序运行时间长，但数据库压力不大
for_,v:=rangeuserList{
user:=db.user.Get(v.ID)
ifuser==nil{
newUser:=user{ID:v.ID,UserName:v.UserName}
db.user.Insert(newUser)
}
}
//使用goroutine，程序运行时间短，但数据库可能被拖垮
for_,v:=rangeuserList{
u:=v
gofunc(){
user:=db.user.Get(u.ID)
ifuser==nil{
newUser:=user{ID:u.ID,UserName:u.UserName}
db.user.Insert(newUser)
}
}()
}
select{}
在示例中，DB在1秒内接收10000次读操作，最大还会接受10000次写操作，普通的DB服务器很难支撑。针对DB，可以在连接池上做手脚，控制访问DB的速度，这里我们讨论两种通用的方法。
方案一
在限速时，一种方案是丢弃请求，即请求速度太快时，对后进入的请求直接抛弃。
实现
实现逻辑如下：
packagemain
import(
"sync"
"time"
)
//LimitRate限速
typeLimitRatestruct{
rateint
begintime.Time
countint
locksync.Mutex
}
//LimitLimit
func(l*LimitRate)Limit()bool{
result:=true
l.lock.Lock()
//达到每秒速率限制数量，检测记数时间是否大于1秒
//大于则速率在允许范围内，开始重新记数，返回true
//小于，则返回false，记数不变
ifl.count==l.rate{
iftime.Now().Sub(l.begin)>=time.Second{
//速度允许范围内，开始重新记数
l.begin=time.Now()
l.count=0
}else{
result=false
}
}else{
//没有达到速率限制数量，记数加1
l.count++
}
l.lock.Unlock()
returnresult
}
//SetRate设置每秒允许的请求数
func(l*LimitRate)SetRate(rint){
l.rate=r
l.begin=time.Now()
}
//GetRate获取每秒允许的请求数
func(l*LimitRate)GetRate()int{
returnl.rate
}
测试
下面是测试代码：
packagemain
import(
"fmt"
)
funcmain(){
varwgsync.WaitGroup
varlrLimitRate
lr.SetRate(3)
fori:=0;i<10;i++{
wg.Add(1)
gofunc(){
iflr.Limit(){
fmt.Println("Gotit!")//显示3次Gotit!
}
wg.Done()
}()
}
wg.Wait()
}
运行结果
Gotit!
Gotit!
Gotit!
只显示3次Gotit!，说明另外7次Limit返回的结果为false。限速成功。
方案二
在限速时，另一种方案是等待，即请求速度太快时，后到达的请求等待前面的请求完成后才能运行。这种方案类似一个队列。
实现
//LimitRate限速
typeLimitRatestruct{
rateint
intervaltime.Duration
lastActiontime.Time
locksync.Mutex
}
//Limit限速
packagemain
import(
"sync"
"time"
)
func(l*LimitRate)Limit()bool{
result:=false
for{
l.lock.Lock()
//判断最后一次执行的时间与当前的时间间隔是否大于限速速率
iftime.Now().Sub(l.lastAction)>l.interval{
l.lastAction=time.Now()
result=true
}
l.lock.Unlock()
ifresult{
returnresult
}
time.Sleep(l.interval)
}
}
//SetRate设置Rate
func(l*LimitRate)SetRate(rint){
l.rate=r
l.interval=time.Microsecond*time.Duration(1000*1000/l.Rate)
}
//GetRate获取Rate
func(l*LimitRate)GetRate()int{
returnl.rate
}
测试
packagemain
import(
"fmt"
"sync"
"time"
)
funcmain(){
varwgsync.WaitGroup
varlrLimitRate
lr.SetRate(3)
b:=time.Now()
fori:=0;i<10;i++{
wg.Add(1)
gofunc(){
iflr.Limit(){
fmt.Println("Gotit!")
}
wg.Done()
}()
}
wg.Wait()
fmt.Println(time.Since(b))
}
运行结果
Gotit!
Gotit!
Gotit!
Gotit!
Gotit!
Gotit!
Gotit!
Gotit!
Gotit!
Gotit!
3.004961704s
与方案一不同，显示了10次Gotit!但是运行时间是3.00496秒，同样每秒没有超过3次。限速成功。
改造
回到最初的例子中，我们将限速功能加进去。这里需要注意，我们的例子中，请求是不能被丢弃的，只能排队等待，所以我们使用方案二的限速方法。
varlrLimitRate//方案二
//限制每秒运行20次，可以根据实际环境调整限速设置，或者由程序动态调整。
lr.SetRate(20)
//使用goroutine，程序运行时间短，但数据库可能被拖垮
for_,v:=rangeuserList{
u:=v
gofunc(){
lr.Limit()
user:=db.user.Get(u.ID)
ifuser==nil{
newUser:=user{ID:u.ID,UserName:u.UserName}
db.user.Insert(newUser)
}
}()
}
select{}
如果您有更好的方案欢迎交流与分享。
内容为作者原创，未经允许请勿转载，谢谢合作。
关于作者：
Jesse，目前在Joygenio工作，从事golang语言开发与架构设计。
正在开发维护的产品：www.botposter.com
本文内容总结：引子，方案一，实现，测试，方案二，实现，测试，改造，
原文链接：https://www.cnblogs.com/jesse-joygenio/p/goroutine-limie-rate.html