Go的上下文应用

1.背景原理

Go上下文就是context。对于go来说go routine（协程）是一个非常有用的方法。
本来用chan（通道）也可以达到控制的目的，无奈如果开的协程太多的话，控制起来就很麻烦。光命名都头疼。
后来又有了sync.WaitGroup来控制，不过好像也没有那么优雅。没有怎么研究。
context(上下文)的出现，优雅的解决了这个问题。
context的原理：

clipboard.png

2.png

context可以创建父子结构，树形结构，如上图。

2.举例说明

设定一个需求：
需要建立一组协程，协程图如下：

main-->A1(协程)-->A1_1(协程)->A1_1_1(协程)
|->B(协程)->B1(协程)
A1熔断时间:5s; A_1熔断时间:4s; A_1_1熔断时间:3s
B1错误，全部结束

上源码：

package main

import (
    "context"
    "fmt"
    "log"
    "time"
)

func main() {
    contextNodeMain()
}

/*
需求概述
主程序的协程
main->A->A_1->A_1_1
   |->B->B1
   主程序的断熔时间为5s;A为4s;A_1为3.5s;A_1_1为3S;
   若B1错误，主程序强制结束
*/
func contextNodeMain() {
    d := time.Now().Add(5000 * time.Millisecond)
    ctx, cancel := context.WithDeadline(context.Background(), d)
    defer func() { cancel() }()
    //B1结束通道
    ch := make(chan bool)
    go A(ctx)
    go B(ctx, ch)

    select {
    case <-ctx.Done(): //全部声明周期燃尽
        log.Println("所有协程关闭") 
    case <-ch: //B1发生错误全部结束
        log.Println("发生错误,其余协程结束")
        return
        //cancel()
    }

}
func B(ctx context.Context, ch chan bool) {
    log.Println("B 开始工作")
    B_1(ch)
}

func B_1(ch chan bool) {
    time.Sleep(time.Second * 10)
    log.Println("B_1 发生错误")
    ch <- false
}

func A(ctx context.Context) {
    ctx_A, cancel := context.WithTimeout(ctx, time.Millisecond*time.Duration(4000)) //A_1执行时间为3.5秒
    log.Println("A 开始工作")
    defer cancel()
    go A_1(ctx_A)
    for {
        select {
        case <-ctx.Done():
            log.Println("A停止工作")
            return
            // case <-time.After(time.Second):
            //  log.Println("A wroking")
        }
    }

}
func A_1(ctx context.Context) {
    ctx_A_1, cancel := context.WithTimeout(ctx, time.Millisecond*time.Duration(3000)) //A_1_1的执行时间为3秒
    log.Println("A_1 开始工作")
    defer cancel()
    go A_1_1(ctx_A_1)
    for {
        select {
        case <-ctx.Done():
            log.Println("A_1停止工作")
            return
        }
    }
}
func A_1_1(ctx context.Context) {
    log.Println("A_1_1 开始工作")
    for {
        select {
        case <-ctx.Done():
            log.Println("A_1_1停止工作")
            return

        }
    }
}

QQ截图20191106100353.png

从结果中我们可以看到
1.10s时，A和B都开始工作。
2.在13秒的时候，A_1_1停止工作，正好是3S。
3.在14s的时候，A_1停止工作，差4s
4.在15S的时候，协程关闭，差5s

也就是按照我们设想的，停止顺序为A_1_1->A_1->A

如果B_1发生错误，我们只需要改一下B，模拟B_1发生错误修改代码如下

func B_1(ch chan bool) {
    time.Sleep(time.Second * 3)
    log.Println("B_1 发生错误")
    ch <- false
}

结果如下：

QQ截图20191106101013.png

如果B_1发生错误，协程全部关闭。