go实现服务优雅关闭的示例

为什么需要优雅关闭

什么叫优雅关闭？先说不优雅关闭，就是什么都不管，强制关闭进程，这会导致有些正在处理中的请求被强行中断

这样做有什么问题？

• 用户本次请求会失败，降低用户体验

• 没有事务的数据库操作，会产生部分成功的问题，破坏原子性

• 某些缓服务需要定期将本地缓存刷到远程db，强制关闭会导致数据丢失

优雅关闭的核心是以下功能：

• 如何监听退出信号

• 如何拒绝新请求

• 如何等待进行中的请求处理完毕

监控服务退出信号

在go中使用下面的代码监听退出信号，如果c返回，说明监听到信号

不同的操作系统监听不同的退出信号

c := make(chan os.Signal, 1)
signals := []os.Signal{
  syscall.SIGINT,
  syscall.SIGTERM,
  syscall.SIGQUIT,
}

signal.Notify(c, signals...)
<-c

拒绝新请求

go在1.8后增加了shutdown方法来，我们看看它怎么实现优雅关闭：

srv.inShutdown.setTrue()
lnerr := srv.closeListenersLocked()
srv.closeDoneChanLocked()

• 设置inShutdown标志位

• 关闭所有的listener

• 关闭doneChan

这一段对应到http服务接收请求的流程：

for {
  rw, err := l.Accept()
  if err != nil {
     select {
     case <-srv.getDoneChan():
        return ErrServerClosed
  // ...      
}

一旦关闭listener，关闭doneChan后，http服务就不会再接收新的请求，直接返回

执行关闭之前的回调

for _, f := range srv.onShutdown {
  go f()
}

这里的回调实现得比较粗糙：

• 没有优先级的概念，所有回调并发执行，因此需要保证回调之间没有依赖

• 虽然回调不适合长时间运行，但Go http没有提供机制来保证这些回调一定能执行完毕，若想做到这点需要自己处理

等待处理中的请求执行完毕

设置标识位可以拒绝新的请求，但依旧在执行的请求还在处理中，需要等这些请求执行完毕

等待处理中的请求执行完毕有两种思路：

• 等待一段固定的时间

• 实时维护请求的计数

go选择了两种方式结合的模式，通过ctx设置一个最大的等待时间，同时不断轮询正在请求中的计数

ctx超时或者计数变为0，都会返回

timer := time.NewTimer(nextPollInterval())
defer timer.Stop()
for {
  if srv.closeIdleConns() && srv.numListeners() == 0 {
     return lnerr
  }
  select {
  case <-ctx.Done():
     return ctx.Err()
  case <-timer.C:
     timer.Reset(nextPollInterval())
  }
}

这里每隔一定时间检查已有请求是否执行完毕，如果执行完毕，或者外部通过ctx设置的超时到期就会返回

检查间隔是多少？

• 从1ms开始，每轮检查后倍增，最大500ms

怎么判断是否执行完毕？

• 所有的连接都关闭

• 所有的listener都关闭

服务收到监听信号返回之前，关闭连接和listener，会被这里检查到

实战

func main() {
  // 注册路由
  http.Handle("/aaa", http.HandlerFunc(func(writer http.ResponseWriter, req *http.Request) {
     time.Sleep(time.Second * 10)
     fmt.Println(111)
  }))
  server := http.Server{
     Addr:    "localhost:8080",
     Handler: http.DefaultServeMux,
  }

close := make(chan int)
  go func() {
     quit := make(chan os.Signal)
     signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
     <-quit

ctx, cancel := context.WithTimeout(context.Background(), time.Second*30)
     defer cancel()
     err := server.Shutdown(ctx)
     log.Print(err)

// 控制外层退出
     close <- 1
  }()

err := server.ListenAndServe()
  fmt.Println(err)

<-close
}

该代码做了下面的事：

• 注册一个10s才返回的路由处理函数

• 开子协程监听OS的退出信号，如果监听到了开始进行优雅关闭，虽多等待30s

• 主协程调用 server.ListenAndServe()，开始监听请求

需要注意的是，一定要在子协程中优雅关闭结束后，主协程才能退出，这里用channel控制

因为主协程发现doneChan被关闭时会马上返回，但此时主协程开的业务处理协程还在进行中，如果主协程此时退出，无法达到优雅关闭的效果

按照以下流程测试：

• 启动 Web 服务

• 在浏览器请求http://localhost:8080/aaa

• 过5秒后在控制台按下ctrl+c

• 观察控制台程序是否不会立刻结束，而是在 10s 后结束

支持强制退出

既然有优雅退出，那就有强制退出，我们假设如果按下两次ctrl+c，代表用户希望服务强制退出：

close := make(chan int, 2)
go func() {
  quit := make(chan os.Signal)
  signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
  <-quit
  go func() {
     <-quit
     os.Exit(1)
  }()

// ...
}()

做法很简单，收到第一个退出信号后，再开一个子协程，如果再收到退出信号，就调用os.Exit退出进程

并且close channel的容量需要为2，避免当两次退出信号过短时丢失信号

来源：https://blog.csdn.net/qq_39383767/article/details/128886199