使用 golang 标准解法 context

最简单的 http 服务端

咱们来写一个简单的 http 服务器

func main() {
    srvMux := http.NewServeMux()
    srvMux.HandleFunc("/getinfo", getinfo)
    http.ListenAndServe(":9090", srvMux)

}

func getinfo(w http.ResponseWriter, r *http.Request) {
    fmt.Println("i am xiaomotong!!!")
    w.Write([]byte("you are access right!!\n"))
}

9090/getinfo

# curl localhost:9090/getinfo
you are access right!!

明确是可以正常访问的，且也会拿到我们对应的信息，服务器的日志也是正常的

咱们思考一下，这个时候如果遇到了意外，程序崩溃了，panic 了，或者我们认为的 kill 掉了，我们如何判断服务端是如何退出的呢？

加入信号的服务端

我们写 C/C++ 的时候对于信号应该不陌生吧，在 golang 里面，我们也加入信号来识别是否是认为 kill 程序的

man kill

 kill -9   SIGKILL Ctrl-C

func main() {
    sig := make(chan os.Signal)
    signal.Notify(sig, syscall.SIGINT, syscall.SIGKILL)

    srvMux := http.NewServeMux()
    srvMux.HandleFunc("/getinfo", getinfo)
    go http.ListenAndServe(":9090", srvMux)

     fmt.Println(<-sig)
}

http.ListenAndServe9090

验证一下

# go run main.go
^Cinterrupt

这个时候，我们的 http 服务器，已经能够区分信号了，知道自己是如何退出的了

咱们的需求有慢慢的增加，实际工作中，肯定不能做的这么 cuo

优雅的退出

工作中，我们带有 http 的服务端，肯定还有别的处理逻辑，例如读写文件，GRPC 通信，或者是使用数据库，那么我们程序关闭情况，还是要根据情况来处理，要遵循原子性

有如下 2 种情况：

对于数据没有严格的质量要求，程序 panic 也无所谓，那么这个时候不用优雅关闭也没有啥问题
对于上述说到的会操作数据库，读写文件等等会修改数据的，这里可不期望操作数据的过程中被中断，我们要遵循原子性，咱们的程序需要提供一个缓冲的时间，来优雅的退出

正常工作中退出必须是优雅的

如何实现优雅退出呢？

例如上面的例子，当主协程收到了中断信号后，就会马上退出程序，子协程也会相应退出

如果需要主协程等待子协程处理完当前手里的活再退出，那么我们是不是需要让主协程和子协程相互通信，才有可能实现呢？

使用 2 个 channel 来实现优雅关闭

这个方法比较容易想到

实现大体分为 2 步走：

主协程收到中断信号后，通知子协程优雅关闭，这里命名为 stopCh
子协程收到通知后，处理完手头的通知主协程关闭程序，这里命名为 closeCh

func main() {
    sig := make(chan os.Signal)
    signal.Notify(sig, syscall.SIGINT, syscall.SIGKILL)

    stopCh := make(chan int)
    closeCh := make(chan int)

    srvMux := http.NewServeMux()
    srvMux.HandleFunc("/getinfo", getinfo)
    go http.ListenAndServe(":19999", srvMux)

    go func(stopCh, closeCh chan int) {
        for {
            select {
            case <-stopCh:
                fmt.Println(" processing tasks")
                // 模拟正在处理数据
                time.Sleep(time.Second*time.Duration(2))
                fmt.Println("process over ")
                closeCh <- 1
            }
        }
    }(stopCh, closeCh)

    <-sig
    stopCh <- 1
    <-closeCh
    fmt.Println("close server ")
}

此处我们可以看出使用了 2 个通道来让主协程和子协程相互通信

开辟一个协程，执行匿名函数来监听 stopCh 通道是否有数据，若有数据，说明主协程收到了信号，并且通知子协程要优雅关闭了

这个时候，子协程做完自己的事情，就在 closeCh 写入数据，通知主协程可以正常关闭程序了

使用嵌套的 channel 来实现

使用嵌套的 channel 来实现优雅关闭，可能一下子还想不到，不过官网有给我们一些方向

实现思路是：

使用一个通道 stopCh，通道 stopCh 里面的元素是另外一个通道 tmpCh
当主协程收到退出信号时，在 stopCh 中写入数据 tmpCh，并开始监听 tmpCh 是否有数据
子协程从 stopCh 读取到数据 tmpCh 时，便知道自己需要优雅关闭了，处理完自己的事情之后，子协程往 tmpCh 写入数据
主协程监听到 tmpCh 有数据，则退出程序

func main() {
    sig := make(chan os.Signal)
    signal.Notify(sig, syscall.SIGINT, syscall.SIGKILL)

    stopCh := make(chan chan struct{})

    srvMux := http.NewServeMux()
    srvMux.HandleFunc("/getinfo", getinfo)
    go http.ListenAndServe(":19999", srvMux)

    go func(stopCh chan chan struct{}) {
        for {
            select {
            case tmpCh:=<-stopCh:
                fmt.Println(" processing tasks")
                time.Sleep(time.Second*time.Duration(2))
                fmt.Println("process over ")
                tmpCh <- struct{}{}
            }
        }
    }(stopCh)

    tmpCh := make(chan struct{})

    <-sig
    stopCh <- tmpCh
    <-tmpCh
    fmt.Println("close server ")
}

上面 2 种方法都比较类似，都是使用通道来实现优雅关闭的功能，通道是 golang 天生的数据结构，咱们要用起来