本文將介紹首先為什麼需要主動關閉goroutine，並介紹如何在Go語言中關閉goroutine的常見套路,包括傳遞終止訊號和協程內部捕捉終止訊號。之後，文章列舉了需要主動關閉協程執行的常見場景，如啟動一個協程執行一個不斷重複的任務。希望通過本文的介紹，讀者能夠掌握如何在適當的時候關閉goroutine，以及瞭解關閉goroutine的常見套路。
瞭解協程的生命週期是優雅地關閉協程的前提，因為在關閉協程之前需要知道協程的當前狀態，以便採取相應的措施。所以這裡我們需要先了解下goroutine的生命週期。
在 Go語言中，協程（goroutine）是一種輕量級的執行緒，可以在一個程式中同時執行多個協程，提高程式的並行效能。協程的生命週期包括建立、執行和結束三個階段。
首先需要建立一個協程，協程的建立可以通過關鍵字 go 來實現，例如：
go func() {
// 協程執行的程式碼
}()
上面的程式碼會啟動一個新的協程，同時在新的協程中執行匿名函數，此時協程便已被建立了。
一旦協程被建立，它就會在新的執行緒中執行。協程的執行狀態可以由 Go 執行時（goroutine scheduler）來管理，它會自動將協程排程到適當的P中執行，並確保協程的公平排程和平衡負載。
在執行階段，協程會不斷地執行任務，直到任務完成或者遇到終止條件。在終止階段，協程將會被回收，從而完成其整個生命週期。
綜上所述，協程由go關鍵字啟動，在協程中執行其業務邏輯，直到最後遇到終止條件，此時代表著協程的任務已經結束了，將進入終止階段。最終協程將會被回收。
正常來說，都是協程任務執行完成之後，此時協程自動退出，例如:
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，協程將滿足終止條件，退出執行。
從上面協程的終止條件來看，正常情況下，協程只要將任務正常處理完成，協程自動退出，此時並不需要主動關閉goroutine。
這裡先舉一個生產者消費者的例子，在這個例子中，我們建立了一個生產者和一個消費者，它們之間通過一個channel進行通訊。生產者生產資料並行送到一個channel中，消費者從這個channel中讀取資料並進行處理。程式碼範例如下:
func main() {
// 生產者程式碼
go func(out chan<- int) {
for i := 0; ; i++ {
select {
case out <- i:
fmt.Printf("producer: produced %d\n", i)
time.Sleep(time.Second)
}
}
// 消費者邏輯
go func(in <-chan int) {
for {
select {
case i := <-in:
fmt.Printf("consumer: consumed %d\n", i)
}
}
}
// 讓生產者協程和消費者協程一直執行下去
time.Sleep(100000000)
}
在這個例子中，我們使用了兩個goroutine：生產者和消費者。生產者向channel中生產資料，消費者從channel中消費資料。
但是，假如生產者出現了問題，此時生產者的協程將會被退出，不再執行。而消費者仍然在等待資料的輸入。此時消費者協程已經沒有存在的必要了，其實是需要退出執行。
因此，對於一些雖然沒有達到終止條件的協程，但是其又沒有再繼續執行下去的必要，此時主動關閉其執行，從而保證程式的健壯性和效能。
優雅得關閉goroutine的執行，我們可以遵循以下三個步驟。首先是傳遞關閉協程的訊號，其次是協程內部需要能夠到關閉訊號，最後是協程退出時，能夠正確釋放其所佔據的資源。通過以上步驟，可以保在需要時優雅地停止goroutine的執行。下面對這三個步驟詳細進行講解。
首先是通過給goroutine傳遞關閉協程的訊號，從而讓協程進行退出操作。這裡可以使用context.Context來傳遞訊號，具體實現可以通過呼叫WithCancel,WithDeadline,WithTimeout等方法來建立一個帶有取消功能的Context，並在需要關閉協程時呼叫Cancel方法來向Context傳送取消訊號。範例程式碼如下：
ctx, cancel := context.WithCancel(context.Background())
go func(ctx context.Context) {
for {
select {
// 呼叫cancel函數後,這裡將能夠收到通知
case <-ctx.Done():
return
default:
// do something
}
}
}(ctx)
// 在需要關閉協程時呼叫cancel方法傳送取消訊號
cancel()
這裡，當我們想要終止協程的執行時，只需要呼叫可取消context物件的Cancel方法，協程內部將能夠通過context物件接收到終止協程執行的通知。
協程內部也需要在取消訊號傳遞過來時，能夠正確被捕捉到，才能夠正常終止流程。這裡我們可以使用select語句來監聽取消訊號。select語句可以有多個case子句，可以同時監聽多個channel，當select語句執行時，它會一直阻塞，直到有一個case子句可以執行。select語句也可以包含default子句，這個子句在所有的case子句都不能執行時會被執行，通常用於防止select語句的阻塞。如下:
select {
case <-channel:
// channel有資料到來時執行的程式碼
default:
// 所有channel都沒有資料時執行的程式碼
}
而context物件的Done方法剛好也是返回一個channel,取消訊號便是通過該channel來進行傳遞的。所以我們可以在協程內部，通過select語句，在其中一個case分支來監聽取消訊號；同時使用一個default分支在協程中執行具體的業務邏輯。在終止訊號沒有到來時，就執行業務邏輯；在收到協程終止訊號後，也能夠及時終止協程的執行。如下:
go func(ctx context.Context) {
for {
select {
// 呼叫cancel函數後,這裡將能夠收到通知
case <-ctx.Done():
return
default:
// 執行業務邏輯
}
}
}(ctx)
最後，當協程被終止執行時，需要釋放佔用的資源，包括檔案控制程式碼、記憶體等，以便其他程式可以繼續使用這些資源。在Go語言中，可以使用defer語句來確保協程在退出時能夠正確地釋放資源。比如協程中開啟了一個檔案，此時可以通過defer語句來關閉，避免資源的洩漏。程式碼範例如下:
func doWork() {
file, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
defer file.Close()
// Do some work
}
在這個例子中，我們在檔案開啟之後使用defer語句註冊了一個函數，當協程結束時會自動呼叫該函數來關閉檔案。這樣協程無論在何時退出，我們都可以確保檔案被正確關閉，避免資源洩漏和其他問題。
下面展示一個簡單的例子，結合Context物件，select語句以及defer語句這三部分內容，優雅得終止一個協程的執行，具體程式碼範例如下:
package 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)
}
在main函數中，我們使用context.WithCancel函數建立了一個新的context，並將其傳遞給worker函數，同時啟動協程執行worker函數。
當worker函數執行5s後，主協程呼叫cancel函數來終止worker協程。之後，worker協程中監聽取消訊號的select語句，將能夠捕捉到這個訊號，執行終止協程操作。
最後，在退出協程時，通過defer語句實現資源的釋放。綜上，我們實現了協程的優雅關閉，同時也正確回收了資源。
協程在執行一個不斷重複的任務時，此時協程是不會主動終止執行的。但是在某個時刻之後，不需要再繼續執行該任務了，需要主動關閉goroutine的執行，釋放協程的資源。
這裡以etcd為例來進行說明。etcd主要用於在分散式系統中儲存設定資訊、後設資料和一些小規模的共用資料。也就是說，我們可以在etcd當中儲存一些鍵值對。那麼，如果我們想要設定鍵值對的有效期，那該如何實現呢?
etcd中存在一個租約的概念，租約可以看作是一個時間段，該時間段內某個鍵值對的存在是有意義的，而在租約到期後，該鍵值對的存在便沒有意義，可以被刪除，同時一個租約可以作用於多個鍵值對。下面先展示如何將一個租約和一個key進行關聯的範例：
// 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)
}
以上程式碼演示瞭如何在etcd中建立一個租約並將其與一個鍵值對進行關聯。首先，通過etcd使用者端的連線建立了一個Lease範例，該範例提供了一些api，可以建立租約、取消租約和續約租約。然後使用Grant函數建立了一個租約並指定了租約的有效期為10秒。接下來，獲取租約ID，每個租約都有一個唯一的ID。最後，使用Put函數將租約與key進行關聯，從而將該key的有效期設定為該租約的有效期。
所以，我們如果想要操作etcd中鍵值對的有效期，只需要操作租約的有效期即可。
而剛好，etcd其實定義了一個Lease介面，該介面定義了對租約的一些操作，能過建立租約，取消租約，同時也支援續約租約，獲取過期時間等內容，具體如下:
type 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
}
到此為止，我們引出了Lease介面，而其中KeepAlive方法便是我們今日的主角，從該方法定義可以看出，當呼叫KeepAlive方法對某個租約進行續約後，其每隔一段時間都會執行對目標租約的續約操作。這個時候一般都是啟動一個協程，由協程來完成對租約的續約操作。
此時協程其實就是在執行一個不斷重複的任務，那如果Lease介面的範例呼叫了Close方法，想要回收掉Lease範例，不會再通過該範例對租約進行操作，回收掉Lease所有佔據的資源，那麼KeepAlive方法建立的協程，此時也應該被主動關閉，不應該再繼續執行下去。
事實上，當前etcd中Lease介面中KeepAlive方法的預設實現也是如此。並且對主動關閉協程執行的實現，也是通過context傳遞物件，select獲取取消訊號，最後通過defer 來回收資源這三者組合起來實現的。
下面來看看執行續約操作的函數，會啟動一個協程在後臺不斷執行，具體實現如下:
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 放入 tosend 陣列中，並在迴圈的下一步中向 etcd叢集傳送續約請求。接著會等待 500 毫秒，然後再次執行上述操作。正常情況下，其不會退出迴圈，會一直向etcd叢集傳送續約請求。除非收到了終止訊號，其才會退出，從而正常結束協程。
而stopCtx則是lessor範例的變數，用於傳遞取消訊號。在建立 lessor 範例時，stopCtx 是由 context.WithCancel() 函數建立的。這個函數會返回兩個物件：一個帶有取消方法的 context.Context 物件（即 stopCtx），以及一個函數物件 stopCancel，呼叫這個函數會取消上下文物件。具體如下:
// 建立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() 協程會在 stopCtx 上等待訊號，所以一旦呼叫了 stopCancel()，協程會收到訊號並退出。這個機制非常靈活，因為stopCtx是範例的成員變數，所以lessor範例建立的所有協程，都可以通過監聽stopCtx來決定是否要退出執行。
這篇文章主要介紹了為什麼需要主動關閉goroutine，以及在Go語言中關閉goroutine的常見套路。
文章首先介紹了為什麼需要主動關閉goroutine。接下來，文章詳細介紹了Go語言中關閉goroutine的常見套路，包括傳遞終止訊號和協程內部捕捉終止訊號。在傳遞終止訊號的方案中，文章介紹瞭如何使用context物件傳遞訊號，並使用select語句等待訊號。在協程內部捕捉終止訊號的方案中，文章介紹瞭如何使用defer語句來回收資源。
最後，文章列舉了需要主動關閉協程執行的常見場景，如協程在執行一個不斷重複的任務，在不再需要繼續執行下去的話，就需要主動關閉協程的執行。希望通過本文的介紹，讀者能夠掌握如何在適當的時候關閉goroutine，從而避免資源浪費的問題。