前言

在golang中，只需要在函數調用前加上關鍵字go即可創建一個并發任務單元，而這個新建的任務會被放入隊列中，等待調度器安排。相比系統的MB級別線程棧，goroutine的自定義棧只有2KB，這使得我們能夠輕易創建上萬個并發任務，如此對性能提升不少。但隨之而來的有以下幾個問題：

如何等待所有goroutine的退出

如何限制創建goroutine的數量（信號量實現）

怎么讓goroutine主動退出

探索——如何從外部殺死goroutine

本文記錄了筆者就以上幾個問題進行探究的過程，文中給出了大部分問題的解決方案，同時也拋出了未解決的問題，期待與各位交流：p

準備

開始之前先定義一個常量const N=100以及一個HeavyWork函數，假定該函數具有極其冗長、復雜度高、難以解耦的特性

func HeavyWork(id int) { rand.Seed(int64(id)) interval := time.Duration(rand.Intn(3)+1) * time.Second time.Sleep(interval) fmt.Printf("HeavyWork %-3d cost %v/n", id, interval)}

以上定義的內容將在之后的代碼中直接使用以縮減篇幅，大部分完整代碼可在 Github: explore-goroutine 中找到

如何等待所有goroutine的退出

"Do not communicate by sharing memory; instead, share memory by communicating"——GO的一大設計哲學《Share Memory By Communicating》

翻譯成中文就是，用通信來共享內存數據，而不要通過共享內存數據來進行通信。

Go中的goroutines和channel提供了一種優雅而獨特的結構化并發軟件的方法，我們可以利用通道(channel)的特性，來實現當前等待goroutine的操作。但是channel并不是當前這個場景的最佳方案，用它來實現的方式是稍顯笨拙的，需要知道確定個數的goroutine，同時稍不注意就極易產生死鎖，代碼如下：

// "talk is cheap, show me the code."func main() { waitChan := make(chan int, 1) for i := 0; i < N; i++ {  go func(n int) {   HeavyWork(n)   waitChan <- 1  }(i) } cnt := 0 for range waitChan {  cnt++  if cnt == N {   break  } } close(waitChan) fmt.Println("finished")}

上述代碼使用了一個緩存大小為1的通道(channel)，創建N個goroutine用于運行HeavyWork，每個任務完成后向waitChan寫入一個數據，在收到N個完成信號后退出。

但事實上比較優雅的方式是使用go標準庫sync，其中提供了專門的解決方案sync.WaitGroup用于等待一個goroutines集合的結束

// "talk is cheap, show me the code."func main() { wg := sync.WaitGroup{} for i := 0; i < N; i++ {  wg.Add(1)  go func(n int) {   defer wg.Done()   HeavyWork(n)  }(i) } wg.Wait() fmt.Println("finished")}

關于sync.WaitGroup的具體使用請參照官方文檔[GoDoc] sync.WaitGroup ，這里不再贅述

如何限制goroutine的創建數量（信號量實現）

信號量(Semaphore)，有時被稱為信號燈，是在多線程環境下使用的一種設施，是可以用來保證兩個或多個關鍵代碼段不被并發調用。

其中V操作會增加信號量的數值即釋放資源，而P操作會減少它即占用資源

那么非常容易想到的就是利用channel（通道）緩存有限的特性，它允許我們可以自實現一個簡單的數量控制，就如同使用信號量一般，在這基礎再加上前面提到的sync.WaitGroup，我們可以打出一套組合拳，提供可阻塞的信號量PV操作，能夠實現固定創建goroutine數量并且支持等待當前goroutine的退出。結構體定義如下：

type Semaphore struct { Threads chan int Wg  sync.WaitGroup}

而P操作只需在channel中加入一個元素同時調用WaitGroup.Add即可，這一操作完成對資源的申請

func (sem *Semaphore) P() { sem.Threads <- 1 sem.Wg.Add(1)}

相反則是V操作，進行資源的釋放

func (sem *Semaphore) V() { sem.Wg.Done() <-sem.Threads}

Wait則阻塞等待直到當前所有資源都歸還，直接調用WaitGroup的方法即可

func (sem *Semaphore) Wait() { sem.Wg.Wait()}

完整代碼可以在 Github: semaphore 中查看

利用上面的信號量就可以做到，在一個時刻的goroutines數量不會超過信號量值的大小，而某個goroutine退出后將返還占用的信號量，而正在等待的goroutine就可以立即申請，下圖形象地展現了運行時的狀態

怎么讓goroutine主動退出

對于goroutine的主動退出，比較友好的做法就是循環監聽一個channel，通過類似信號的方式來告知goroutine的”該退出了“，然后goroutine自己主動退出，這種做法在網上十分常見，也是Golang官方推薦的做法，思想也很簡單。

func main() { ok, quit := make(chan int, 1), make(chan int, 1) go func() {  i := 0  for {   select {   case <-quit:    ok <- 1    return   default:    HeavyWork(i)    i++   }  } }() time.Sleep(5 * time.Second) quit <- 1 <-ok}

運行結果如下圖

探索——如何從外部殺死goroutine

上面講了一些關于goroutines和channel的簡單使用，接下來終于寫到本文的重點了。筆者并沒有解決如何從外部殺死一個goroutine，但記錄了嘗試“殺死”中的可行或不可行方法，希望對各位有所幫助。

因為近期在開發中遇到這樣一個問題，當一個函數是極其冗長、復雜度高、難以解耦的順序結構代碼時（例如某個極其復雜無循環結構的加密算法），而且由于數據量巨大，需要反復調用該函數，由于每運行一次，程序都會消耗大量的時間、空間，那么當一個任務已經被用戶拋棄時，如何才能拋棄仍在做著無用功的goroutine？

為了達到“殺死goroutine”的目的，筆者做了很多嘗試，如

select結構（條件實現）

panic退出機制（失敗）

獲取pid殺死（失敗）

ptrace單步調試（失?。?/p>

...（失?。?/p>

利用select語句實現

關于“如何殺死goroutine”，網上有一部分答案就是利用select實現的，但是這種方式實現的代碼并不適用于服務類的程序，但是對于一般非服務類程序的確能夠實現殺死goroutine的效果，代碼如下：

func main() { wrapper := func() chan int {  c := make(chan int)  go func() {   HeavyWork(0)   c <- 1  }()  return c } select { case <-wrapper(): case <-time.After(1 * time.Second):  fmt.Println("time limit exceed") } // time.Sleep(3 * time.Second)}

但是一旦主函數沒有立即退出，而是作為某種服務而繼續運行時，這里刪除了main函數的最后一行注釋time.Sleep(3 * time.Second)，延遲三秒后退出。可以看見盡管已經超時并輸出"time limit exceed"之后，HeavyWork在main函數沒退出前依舊在運行。效果如下

所以使用select-timeout的方式比較適合實時退出類型的程序，能夠實現一定程度上的并發控制，

小結

就目前而言，還沒有完美的方案來解決控制goroutine的問題，事實上Go似乎并不允許和推薦人們直接控制goroutine，所以暫時還無法做到從外部直接控制goroutine的生命周期，所以比較推薦的做法還是只能通過goroutine主動退出的方法，循環監聽channel，在發出退出信號后最多只消耗一輪資源后就退出，但這就要求該代碼具有循環結構否則就很難使用。有更好解決方案的朋友，請務必告訴我！

以上這篇Golang 探索對Goroutine的控制方法(詳解)就是小編分享給大家的全部內容了，希望能給大家一個參考，也希望大家多多支持VEVB武林網。