Go关闭goroutine协程的方法
这篇文章主要介绍了Go关闭goroutine协程的方法，具有一定借鉴价值，需要的朋友可以参考下。下面就和我一起来看看吧。
1.简介
本文将介绍首先为什么需要主动关闭
goroutinegoroutinegoroutinegoroutine2.为什么需要关闭goroutine
2.1 协程的生命周期
了解协程的生命周期是优雅地关闭协程的前提，因为在关闭协程之前需要知道协程的当前状态，以便采取相应的措施。所以这里我们需要先了解下
goroutine在
Go首先需要创建一个协程，协程的创建可以通过关键字 go 来实现，例如：
go func() {
// 协程执行的代码
}()上面的代码会启动一个新的协程，同时在新的协程中执行匿名函数，此时协程便已被创建了。
一旦协程被创建，它就会在新的线程中运行。协程的运行状态可以由 Go 运行时（goroutine scheduler）来管理，它会自动将协程调度到适当的
P在运行阶段，协程会不断地执行任务，直到任务完成或者遇到终止条件。在终止阶段，协程将会被回收，从而完成其整个生命周期。
综上所述，协程由
go2.2 协程的终止条件
正常来说，都是协程任务执行完成之后，此时协程自动退出，例如:
func main() {
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
// 协程执行的代码
fmt.Println("协程执行完毕")
}()
wg.Wait()
// 等待协程执行完毕
fmt.Println("主程序结束")上面的代码中，我们使用
WaitGroup还有一种情况是协程发生panic，它将会自动退出。例如：
func main() {
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
// 协程执行的代码
panic("协程发生错误")
}()
// 等待协程执行完毕
wg.Wait()
fmt.Println("主程序结束")
}在这种情况下，协程也会自动退出，不会再占用系统资源。
综合看来，协程的终止条件，其实就是协程中的任务执行完成了，或者是执行过程中发生了panic，协程将满足终止条件，退出执行。
2.3 为什么需要主动关闭goroutine
从上面协程的终止条件来看，正常情况下，协程只要将任务正常处理完成，协程自动退出，此时并不需要主动关闭
goroutine这里先举一个生产者消费者的例子，在这个例子中，我们创建了一个生产者和一个消费者，它们之间通过一个
channelchannelchannelfunc main() {
// 生产者代码
go func(out chan<- int) {
for i := 0; ; i++ {
select {
case out <- i:
fmt.Printf("producer: produced %d
", i)
time.Sleep(time.Second)
}
}
// 消费者逻辑
go func(in <-chan int) {
for {
select {
case i := <-in:
fmt.Printf("consumer: consumed %d
", i)
}
}
}
// 让生产者协程和消费者协程一直执行下去
time.Sleep(100000000)
}在这个例子中，我们使用了两个
goroutinechannelchannel但是，假如生产者出现了问题，此时生产者的协程将会被退出，不再执行。而消费者仍然在等待数据的输入。此时消费者协程已经没有存在的必要了，其实是需要退出执行。
因此，对于一些虽然没有达到终止条件的协程，但是其又没有再继续执行下去的必要，此时主动关闭其执行，从而保证程序的健壮性和性能。
3.如何优雅得关闭goroutine
优雅得关闭
goroutinegoroutine3.1 传递关闭终止信号
首先是通过给
goroutinecontext.ContextWithCancelWithDeadlineWithTimeoutContextCancelContextctx, cancel := context.WithCancel(context.Background())
go func(ctx context.Context) {
for {
select {
// 调用cancel函数后,这里将能够收到通知
case <-ctx.Done():
return
default:
// do something
}
}
}(ctx)
// 在需要关闭协程时调用cancel方法发送取消信号
cancel()这里，当我们想要终止协程的执行时，只需要调用可取消
contextCancelcontext3.2 协程内部捕捉终止信号
协程内部也需要在取消信号传递过来时，能够正确被捕捉到，才能够正常终止流程。这里我们可以使用
selectselectcasechannelselectcaseselectselect {
case <-channel:
// channel有数据到来时执行的代码
default:
// 所有channel都没有数据时执行的代码
}而
contextDonechannelchannelselectcasedefaultgo func(ctx context.Context) {
for {
select {
// 调用cancel函数后,这里将能够收到通知
case <-ctx.Done():
return
default:
// 执行业务逻辑
}
}
}(ctx)3.3 回收协程资源
最后，当协程被终止执行时，需要释放占用的资源，包括文件句柄、内存等，以便其他程序可以继续使用这些资源。在Go语言中，可以使用
deferfunc doWork() {
file, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
defer file.Close()
// Do some work
}在这个例子中，我们在文件打开之后使用
defer3.4 关闭goroutine示例
下面展示一个简单的例子，结合
Contextselectdeferpackage main
import (
"context"
"fmt"
"time"
)
func worker(ctx context.Context) {
// 最后,在协程退出前,释放资源.
defer fmt.Println("worker stopped")
for {
// 通过select语句监听取消信号,取消信号没到达,则执行业务逻辑,等下次循环检查
select {
default:
fmt.Println("working")
case <-ctx.Done():
return
}
time.Sleep(time.Second)
}
}
func main() {
ctx, cancel := context.WithCancel(context.Background())
// 启动一个协程执行任务
go worker(ctx)
// 执行5s后,调用cancel函数终止协程
time.Sleep(5 * time.Second)
cancel()
time.Sleep(2 * time.Second)
}在
maincontext.WithCancelcontextworkerworker当
workercancelworkerworkerselect最后，在退出协程时，通过
defer4. 需要主动关闭协程运行的常见场景
4.1 协程在执行一个不断重复的任务
协程在执行一个不断重复的任务时，此时协程是不会主动终止运行的。但是在某个时刻之后，不需要再继续执行该任务了，需要主动关闭
goroutine这里以
etcdetcdetcdetcd// client 为 etcd客户端的连接,基于此建立一个Lease实例
// Lease示例提供一些api,能过创建租约，取消租约,续约租约
lease := clientv3.NewLease(client)
// 创建一个租约,同时租约时间为10秒
grantResp, err := lease.Grant(context.Background(), 10)
if err != nil {
log.Fatal(err)
}
// 租约ID,每一个租约都有一个唯一的ID
leaseID := grantResp.ID
// 将租约与key进行关联,此时该key的有效期,也就是该租约的有效期
_, err = kv.Put(context.Background(), "key1", "value1", clientv3.WithLease(leaseID))
if err != nil {
log.Fatal(err)
}以上代码演示了如何在
etcdetcdLeaseGrantPut所以，我们如果想要操作
etcd而刚好，
etcdLeasetype Lease interface {
// 1. 创建一个新的租约
Grant(ctx context.Context, ttl int64) (*LeaseGrantResponse, error)
// 2. 取消租约
Revoke(ctx context.Context, id LeaseID) (*LeaseRevokeResponse, error)
// 3. 获取租约的剩余有效期
TimeToLive(ctx context.Context, id LeaseID, opts ...LeaseOption) (*LeaseTimeToLiveResponse, error)
// 4. 获取所有的租约
Leases(ctx context.Context) (*LeaseLeasesResponse, error)
// 5. 不断对租约进行续约，这里假设10s后过期，此时大概的含义为每隔10s续约一次租约,调用该方法后,租约将永远不会过期
KeepAlive(ctx context.Context, id LeaseID) (<-chan *LeaseKeepAliveResponse, error)
// 6. 续约一次租约
KeepAliveOnce(ctx context.Context, id LeaseID) (*LeaseKeepAliveResponse, error)
// 7. 关闭Lease实例
Close() error
}到此为止，我们引出了
LeaseKeepAliveKeepAlive此时协程其实就是在执行一个不断重复的任务，那如果
LeaseCloseLeaseLeaseKeepAlive事实上，当前
etcdLeaseKeepAlivecontextselectdefer下面来看看执行续约操作的函数，会启动一个协程在后台不断执行，具体实现如下:
func (l *lessor) sendKeepAliveLoop(stream pb.Lease_LeaseKeepAliveClient) {
for {
var tosend []LeaseID
now := time.Now()
l.mu.Lock()
// keepAlives 是保存了所有待续约的 租约ID
for id, ka := range l.keepAlives {
// 然后nextKeepAlive为下次续约的时间,如果超过该时间,则执行续约操作
if ka.nextKeepAlive.Before(now) {
tosend = append(tosend, id)
}
}
l.mu.Unlock()
// 发送续约请求
for _, id := range tosend {
r := &pb.LeaseKeepAliveRequest{ID: int64(id)}
// 向etcd集群发送续约请求
if err := stream.Send(r); err != nil {
return
}
}
select {
// 每隔500ms执行一次
case <-time.After(500 * time.Millisecond):
// 如果接收到终止信号,则直接终止
case <-l.stopCtx.Done():
return
}
}
}可以看到，其会不断循环，首先会检查当前时间是否超过了所有租约的下次续约时间，如果超过了，则会将这些租约的 ID 放入
tosendetcdetcd而
stopCtxlessorlessorstopCtxcontext.WithCancel()context.ContextstopCtxstopCancel// 创建Lease实例
func NewLeaseFromLeaseClient(remote pb.LeaseClient, c *Client, keepAliveTimeout time.Duration) Lease {
// ...省略一些无关内容
reqLeaderCtx := WithRequireLeader(context.Background())
// 通过withCancel函数创建cancelCtx对象
l.stopCtx, l.stopCancel = context.WithCancel(reqLeaderCtx)
return l
}在
lessor.Close()stopCancel()func (l *lessor) Close() error {
l.stopCancel()
// close for synchronous teardown if stream goroutines never launched
// 省略无关内容
return nil
}因为
sendKeepAliveLoop()stopCtxstopCancel()stopCtxlessorstopCtx5.总结
这篇文章主要介绍了为什么需要主动关闭
goroutinegoroutine文章首先介绍了为什么需要主动关闭
goroutineGogoroutinecontextselectdefer最后，文章列举了需要主动关闭协程运行的常见场景，如协程在执行一个不断重复的任务，在不再需要继续执行下去的话，就需要主动关闭协程的执行。希望通过本文的介绍，读者能够掌握如何在适当的时候关闭
goroutine相关文章