声明：本文CSDN作者原创投稿文章，未经许可禁止任何形式的转载，原文链接
正确退出协程方法容易搜到，记录三个坑。
对象方法协程的错误退出
在golang中，我们声明了一个类型，并创建了对应的对象，将对象的方法以协程方式启动后，不可直接将对象设置为nil来使协程退出，验证如下：
package main
import (
"fmt"
"time"
)
type Node struct {
id int
}
func main() {
n := new(Node)
for i := 0; i < 2; i++ {
go n.test(i)
}
time.Sleep(2 * time.Second)
fmt.Println("使对象为nil")
n = nil
time.Sleep(2 * time.Second)
fmt.Println("主程序退出")
}
func (node *Node) test(n int) {
i := 0
for {
fmt.Println(n, ":", i)
i++
time.Sleep(1 * time.Second)
}
}
程序输出为
1 : 0
0 : 0
0 : 1
1 : 1
使对象为nil
1 : 2
0 : 2
0 : 3
1 : 3
0 : 4
1 : 4
主程序退出
可以看到，main()退出时，协程才会退出。
协程中的协程的错误退出
如果在main()中定义启动一个协程f()，在f()中再启动2个协程，如果f()退出的话，它启动的2个协程是不会退出的，验证如下：
package main
import (
"fmt"
"time"
)
type Node struct {
id int
}
func main() {
go f()
time.Sleep(5 * time.Second)
fmt.Println("主程序退出")
}
func f(){
n := new(Node)
for i := 0; i < 2; i++ {
go n.test(i)
}
time.Sleep(2 * time.Second)
fmt.Println("f退出")
return
}
func (node *Node) test(n int) {
i := 0
for {
fmt.Println(n, ":", i)
i++
time.Sleep(1 * time.Second)
}
}
程序输出为
1 : 0
0 : 0
0 : 1
1 : 1
1 : 2
0 : 2
f退出
1 : 3
0 : 3
0 : 4
1 : 4
主程序退出
可以看到，f()退出时，其启动的协程并未退出。
多个协程的错误退出
当有多个协程并发时，如果要通过发送退出信号的方式将其同时全部关闭，不可使同一通道被两个或两个以上协程监听，验证如下：
package main
import (
"fmt"
"time"
)
type Node struct {
id int
}
var quit = make(chan struct{
})
func main() {
go f()
time.Sleep(5 * time.Second)
fmt.Println("主程序退出")
}
func f() {
n := new(Node)
for i := 0; i < 2; i++ {
go n.test(i)
}
time.Sleep(2 * time.Second)
fmt.Println("使协程退出")
quit <- struct{
}{
}
return
}
func (node *Node) test(n int) {
i := 0
for {
select {
case <-quit:
fmt.Printf("协程%d退出\n", n)
return
default:
fmt.Println(n, ":", i)
i++
time.Sleep(1 * time.Second)
}
}
}
程序输出为
1 : 0
0 : 0
0 : 1
1 : 1
1 : 2
使协程退出
0 : 2
协程0退出
1 : 3
1 : 4
主程序退出
可以看到，向通道发送一次信号，只会有一个协程拿到了信号并将其取出，其他协程就不会再从通道中取到信号，所以也就只有一个协程退出。
一个通道控制多个协程的正确退出方法
使用close()方法把通道关闭，协程检测到通道关闭后，将自身结束，验证如下：
package main
import (
"fmt"
"time"
)
var quit = make(chan struct{
})
func main() {
for i := 0; i < 2; i++ {
go worker(quit)
}
time.Sleep(5 * time.Second)
close(quit)
time.Sleep(2 * time.Second)
fmt.Println("主程序退出")
}
func worker(stopCh <-chan struct{
}) {
defer fmt.Println("worker exit")
t := time.NewTicker(2 * time.Second)
// Using stop channel explicit exit
for {
select {
case _, ok := <-stopCh:
if !ok {
fmt.Println("Recv stop signal")
return
}
case <-t.C:
fmt.Println("Working .")
}
}
}
程序输出为
Working .
Working .
Working .
Working .
Recv stop signal
worker exit
Recv stop signal
worker exit
主程序退出
可以看到启动的协程都结束了。