Golang - 主线程让子线程退出的三种方式

在golang中，主go程告知子go程退出有三种方式，建议用后面两种

方式一：全局变量方式

package main

import (
    "fmt"
    "sync"
    "time"
)
var wg sync.WaitGroup
var exit bool  //零值为false
//方式1全局变量
func mode1() {
    fmt.Println("come in mode1()")
    defer fmt.Println("out of mode1")
    defer wg.Done() //计数器-1

    for {
        time.Sleep(time.Second *1)
        fmt.Println("mode1 say hello go")
        if exit { //主go程，将exit赋值为true时，跳出循环，结束程序
            break
        }
    }
}


func main() {

    fmt.Println("come in main()")
    defer  fmt.Println("out of main()")
    wg.Add(1) //计数器+1
    go mode1()  //开始跑协程
    time.Sleep(time.Second*5) //睡眠5s
    exit = true //当exit=true, 子go程就跳出循环结束
    wg.Wait()  //主线程等待所有子线程结束，等待计数器为0

}

方式二：channel方式

package main

import (
    "fmt"
    "sync"
    "time"
)

var wg sync.WaitGroup

//关于参数传递
//1.chan struct{} 类型空间小 比 chan bool 一字节小，也许是0？
//2.应该（可以）传入exitChan <- chan struct{},代表只能从channel中接收,不能发送
//额外: chan <- struct{} 只能发送，不能接收
func mode2(exitChan  chan struct{}) {
    fmt.Println("come in mode2()")
    defer fmt.Println("out of mode2()")
LOOP:
    for {
        select {
        case <- exitChan: //可以从channel中取出值
            //break //单纯的break 只是跳出select
            break LOOP //break 标签 的作用，跳出for循环，标签定义要在前面
        default:
            fmt.Println("mode2 say hello go")
            time.Sleep(time.Second*1)
        }
    }

}

func main() {
    fmt.Println("come in main()")
    defer fmt.Println("out of main()")
    var exitChan = make(chan struct{}) //这里定义了不带缓存的channel，你也可以定义带缓存的channel
    wg.Add(1)
    go mode2(exitChan)
    time.Sleep(time.Second*5)
    exitChan <- struct{}{} //向channel中写数据
    close(exitChan)//关闭channel
    wg.Wait()

}

方式三：Context方式

package main

import (
    "context"
    "fmt"
    "sync"
    "time"
)

var wg sync.WaitGroup

func mode3(ctx context.Context) {
    fmt.Println("come in mode3()")
    defer fmt.Println("out of mode3")
    defer wg.Done() //计数器-1
    LOOP:
        for {
            fmt.Println("mode3 say hello go")
            time.Sleep(time.Second*1)
            select {
            case <-ctx.Done(): //等待通知
                break LOOP //跳出for循环
            default:

            }
        }
}

func main() {

    fmt.Println("come in main()")
    defer fmt.Println("out of main()")
    ctx, cancel :=context.WithCancel(context.Background())
    wg.Add(1) //计数器+1
    go mode3(ctx) //跑go线程
    time.Sleep(time.Second*5)
    cancel() //通知子线程goroutine结束
    wg.Wait() //等待计数器置为0


}

Go1.7加入了一个新的标准库context。
本质也是channel，传入的也是chan struct{}类型的。

使用全局变量在跨包调用时不容易实现规范和统一，需要维护一个共用的channe。所以官方就提出了一个规范，Context方式的出现。

亲测脚本：

package main

import (
	"fmt"
	"time"
)

//var wg sync.WaitGroup

// 关于参数传递
// 1.chan struct{} 类型空间小 比 chan bool 一字节小，也许是0？
// 2.应该（可以）传入exitChan <- chan struct{},代表只能从channel中接收,不能发送
// 额外: chan <- struct{} 只能发送，不能接收
func mode2(exitChan chan struct{}) {
	fmt.Println("come in mode2()")
	defer fmt.Println("out of mode2()")
LOOP:
	for {
		select {
		case <-exitChan: //可以从channel中取出值
			//break //单纯的break 只是跳出select
			break LOOP //break 标签 的作用，跳出for循环，标签定义要在前面
		default:
			fmt.Println("mode2 say hello go")
			time.Sleep(time.Second * 1)
		}
	}

}

func main() {
	fmt.Println("come in main()")
	defer fmt.Println("out of main()")
	var exitChan = make(chan struct{}) //这里定义了不带缓存的channel，你也可以定义带缓存的channel
	//wg.Add(1)
	go mode2(exitChan)
	time.Sleep(time.Second * 5)
	exitChan <- struct{}{} //向channel中写数据
	//close(exitChan)        //关闭channel
	//wg.Wait()

}