【golang】go app 优雅关机 Graceful Shutdown How?

0 背景     

        我们使用 Go (Golang)来构建一个非常简单的 API 服务器，它可以优雅地关闭。优雅的关闭是指所有进程都被正确关闭，当前正在运行的任何 API 请求都不会被中断，并且将首先完成运行，最后拒绝任何新的 API 请求。

       在本文中，我们将学习构建一个简单的 API 服务器，并了解如何截获外部关机信号，以便通知服务器我们正在关闭。

1 直接关停有什么问题？

• 服务器立即关闭，go程序不会捕捉到错误！
• 如果请求正在处理，它将突然停止。正在处理的请求不会得到相应。下面例子中可以通过添加时间来验证这一点，睡眠(10秒 在请求处理程序中延长请求持续时间)。

2. 不优雅关机版本

• (1)ーー声明一个简单的路由并分配一个处理程序
• (2)ーー启动服务器(程序将在这里停止，而服务器接受请求)
• (3)ーー处理服务器退出时停止接受请求的错误)
• (4)ーー处理请求的简单路由处理程序

package main
 
import (
	"fmt"
	"net/http"
)
 
func main() {
	fmt.Println("Hello, NO Graceful Server!")
 
	// (1) api route and handler
	http.HandleFunc("/hello", HelloAPI_)
 
	// (2) start the server
	err := http.ListenAndServe(":8080", nil)
 
	// (3) handle error on exit
	if err != nil {
		panic(err)
	}
}
 
// (4) A simple basic implementation of handling an API request
func HelloAPI_(w http.ResponseWriter, r *http.Request) {
	time.Sleep(10 * time.Second)
	response := "Hello!"
	w.Write([]byte(response))
}

3. 优雅关机版

• (1)首先我们需要创建一个多路复用器(简称 mux) ，它基本上是一个请求处理程序
• (2)使用 mux，我们注册路由和处理程序。这与我们之前使用 http 包所做的几乎相同
• (3)然后创建服务器。对于这个对象，稍后我们将了解关闭方法
• (4)然后我们通过调用... ListenAndServe
• (5)来启动服务器。如果服务器无法启动，我们可能应该记录错误
• (6)我们需要检查错误是否是由优雅的关闭引起的，并且安全地忽略它
• (7)我们需要以某种方式调用 Shutdown 方法来优雅地关闭服务器并且拒绝正确的请求，等待任何处理请求完成。
• (8)最后，如果不能正确执行关机，我们也会记录错误

package main
 
import (
	"context"
	"fmt"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"
)
 
func main() {
	// print that the application has started
	fmt.Println("Hello, Graceful Server!")
 
	// create a server mux
	serverMux := http.NewServeMux()
 
	// register route and handler
	serverMux.HandleFunc("/hello", HelloAPI__)
 
	// create server
	server := &http.Server{
		Addr:    ":8080",
		Handler: serverMux,
	}
 
	// create channel to capture signal
	sigChn := make(chan os.Signal, 1)
 
	// register channel for signal capturing
    // 注册监听系统信号量
	signal.Notify(sigChn, syscall.SIGINT)
 
	// create channel to capture server error
	startErrChn := make(chan error, 1)
 
	// start the server asynchronously
	go func() {
		// (4) start the server
		err := server.ListenAndServe()
 
		// (5) handle error on exit
		if err != nil {
			if err == http.ErrServerClosed {
				// do nothing...
			} else {
				// log error
				fmt.Println(err)
			}
		}
 
		// inform that server has stopped accepting requests
		startErrChn <- err
	}()
 
	// wait for either a Ctrl+C signal, or server abnormal start error
	select {
 
	// we captured a signal to shut down application
	case <-sigChn:
		// print that server is shutting down
		fmt.Println("server is shutting down")
 
		// trigger the server shutdown gracefully
		err := server.Shutdown(context.Background())
 
		// log any error on graceful exit
		if err != nil {
			fmt.Println(err)
		}
 
	// we have an error from server's listen and serve, which is abnormal shutdown
	case <-startErrChn:
		// since we already logged the error, we may want to log additional details
		fmt.Println("server abnormal shutdown without stop signal!")
	}
	// tidy up and print that we have gracefully shutdown the server
	fmt.Println("Graceful shutdown!")
}
// a long running request
func HelloAPI__(w http.ResponseWriter, r *http.Request) {
	time.Sleep(150 * time.Second)
	response := "Hello!"
	w.Write([]byte(response))
}

 
// Shutdown gracefully shuts down the server without interrupting any
// active connections. Shutdown works by first closing all open
// listeners, then closing all idle connections, and then waiting
// indefinitely for connections to return to idle and then shut down.
// If the provided context expires before the shutdown is complete,
// Shutdown returns the context's error, otherwise it returns any
// error returned from closing the Server's underlying Listener(s).
//
// When Shutdown is called, Serve, ListenAndServe, and
// ListenAndServeTLS immediately return ErrServerClosed. Make sure the
// program doesn't exit and waits instead for Shutdown to return.
//
// Shutdown does not attempt to close nor wait for hijacked
// connections such as WebSockets. The caller of Shutdown should
// separately notify such long-lived connections of shutdown and wait
// for them to close, if desired. See RegisterOnShutdown for a way to
// register shutdown notification functions.
//
// Once Shutdown has been called on a server, it may not be reused;
// future calls to methods such as Serve will return ErrServerClosed.
func (srv *Server) Shutdown(ctx context.Context) error {
	srv.inShutdown.setTrue()
 
	srv.mu.Lock()
	lnerr := srv.closeListenersLocked()
	srv.closeDoneChanLocked()
	for _, f := range srv.onShutdown {
		go f()
	}
	srv.mu.Unlock()
 
	pollIntervalBase := time.Millisecond
	nextPollInterval := func() time.Duration {
		// Add 10% jitter.
		interval := pollIntervalBase + time.Duration(rand.Intn(int(pollIntervalBase/10)))
		// Double and clamp for next time.
		pollIntervalBase *= 2
		if pollIntervalBase > shutdownPollIntervalMax {
			pollIntervalBase = shutdownPollIntervalMax
		}
		return interval
	}
 
	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())
		}
	}
}

 4. 小结&问题

• 1 上面代码如果ctr+c捕获系统信号之后的处理都能解决：「当前正在运行的任何 API 请求都不会被中断」，但是如果代码主动关停确实不行的，为什么呢？如下改动（HelloAPI_最终没有执行完）
•  2. 核心方案（拦截信号）：我们让 Go 系统在信号被拦截时通知我们,使用channel实现；