Golang退出协程的几个错误方法

最新推荐文章于 2025-11-17 10:01:47 发布

原创最新推荐文章于 2025-11-17 10:01:47 发布 · 1.5k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#golang #开发语言 #后端

本文探讨了Go语言中协程的正确退出方法，包括对象方法协程、协程中的协程及多个协程的错误退出情况，并给出了一种正确的退出方案。

声明：本文优快云作者原创投稿文章，未经许可禁止任何形式的转载，原文链接

文章目录

正确退出协程方法容易搜到，记录三个坑。

对象方法协程的错误退出

在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
主程序退出

可以看到启动的协程都结束了。