解决go在函数退出后子协程的退出问题

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)
}

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

	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 函数 退出")

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 函数 退出")