該問題來源于自己在讀fabric源碼時，看到的一個測試代碼，在一個函數中啟用協程，然后該函數退出了，由于平常沒有這樣處理過，以及受原有c++函數域的影響，認為函數退出，子協程應該也退出了呀。
這其實是自己對go協程的理解不到位引起的，go的協程作用域不是在某個函數中的，當然，如果那個函數是main函數，就符合要求了。
該代碼為solo算法的測試代碼：
func goWithWait(target func()) *waitableGo {
wg := waitableGo{
done: make(chan struct{}),
}
go func() {
target()//該協程會阻塞在這
close(wg.done)//用來對外通知
}()
//外邊結束，里邊還不結束嗎？
return wg
}
// This test checks that if consenter is halted before a timer fires, nothing is actually written.
func TestHaltBeforeTimeout(t *testing.T) {
batchTimeout, _ := time.ParseDuration("1ms")
//support的構造還不清楚
support := mockmultichannel.ConsenterSupport{
Blocks: make(chan *cb.Block),
BlockCutterVal: mockblockcutter.NewReceiver(),
SharedConfigVal: mockconfig.Orderer{BatchTimeoutVal: batchTimeout},
}
defer close(support.BlockCutterVal.Block)
bs := newChain(support)
//bs.main是solo算法的啟動函數，是個死循環，處理函數
wg := goWithWait(bs.main)
defer bs.Halt()//中止
syncQueueMessage(testMessage, bs, support.BlockCutterVal)
bs.Halt()
select {
case -support.Blocks:
t.Fatalf("Expected no invocations of Append")
case -wg.done:
}
}
遇到該問題后，我寫了幾個測試：
單純的函數退出，是不會影響協程的
package main
import "fmt"
var ch chan int
func test() int {
ch = make(chan int)
go func() {
for {
fmt.Println(-ch)
fmt.Println("hello")
}
fmt.Println("aaaa")
}()
//不阻塞，那go func()不會異常退出嗎？
//協程并不是函數，不會因為這個函數的退出而退出
//test()啟動一個deadloop子協程,這個會在主協程main結束后被強制退出
return 0
}
func main() {
c := test()
ch - 10
fmt.Println("c", c)
}
我經常在main里邊直接寫協程的測試demo,main退出會結束主協程，之后會強制結束子協程，一般不會遇到上述在普通函數退出的問題，也沒仔細思考，所以分析源碼時有點困惑。
子協程啟動子協程,父協程的退出，并沒有影響到子協程
liudeMacBook-Pro:~ liu$ cat tmp.go
package main
import (
"fmt"
"time"
)
func test() {
go func() { //父協程
defer func() {
fmt.Println("exit dad")
}()
go func() { //子協程
defer func() {
fmt.Println("exit kid")
}()
}()
}()
}
func main() {
test()
time.Sleep(time.Second)
}
liudeMacBook-Pro:~ liu$ go run tmp.go
exit dad
exit kid
補充：golang中父子協程生命周期問題，以及通過context優雅關閉子協程
背景
上次基于mysql實現分布式鎖，今天經過測試發現問題，主要是協程不斷獲取鎖的邏輯存在問題，因為獲取鎖的協程掛掉之后，但其新生成的用來不斷更新鎖的協程并不會退出，導致鎖一直不能被釋放，究其原因如下
原因
通過下面代碼即可說明
fmt.Println("main 函數 開始...")
go func() {
fmt.Println("父 協程 開始...")
go func() {
for {
fmt.Println("子 協程 執行中...")
timer := time.NewTimer(time.Second * 2)
-timer.C
}
}()
time.Sleep(time.Second*5)
fmt.Println("父 協程 退出...")
}()
time.Sleep(time.Second*10)
fmt.Println("main 函數 退出")
main 函數 開始...
父 協程 開始...
子 協程 執行中...
子 協程 執行中...
子 協程 執行中...
父 協程 退出...
子 協程 執行中...
子 協程 執行中...
main 函數 退出
由此可以看出：
main 函數退出，所有協程退出
協程無父子關系，即在父協程開啟新的協程，若父協程退出，不影響子協程
解決方式
通過context上下文來解決，當然也可以通過channel管道來解決，context解決方式如下：
fmt.Println("main 函數 開始...")
go func() {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
fmt.Println("父 協程 開始...")
go func(ctx context.Context) {
for {
for {
select {
case -ctx.Done():
fmt.Println("子 協程 接受停止信號...")
return
default:
fmt.Println("子 協程 執行中...")
timer := time.NewTimer(time.Second * 2)
-timer.C
}
}
}
}(ctx)
time.Sleep(time.Second*5)
fmt.Println("父 協程 退出...")
}()
time.Sleep(time.Second*10)
fmt.Println("main 函數 退出")
main 函數 開始...
父 協程 開始...
子 協程 執行中...
子 協程 執行中...
子 協程 執行中...
父 協程 退出...
子 協程 接受停止信號...
main 函數 退出
以上為個人經驗，希望能給大家一個參考，也希望大家多多支持腳本之家。如有錯誤或未考慮完全的地方，望不吝賜教。
您可能感興趣的文章:- Go 并發實現協程同步的多種解決方法
- go等待一組協程結束的操作方式
- golang協程池模擬實現群發郵件功能
- Go使用協程交替打印字符
- Golang 之協程的用法講解
- go 協程返回值處理操作
- 淺談golang for 循環中使用協程的問題
- Go并發:使用sync.WaitGroup實現協程同步方式
