拦截信号优雅关闭Golang应用

Golang不是像C语言的系统级编程语言，但仍提供了以下特性帮助开发者与底层操作系统进行交互，如信号（singals),os/singals包实现了这些功能。相对于其他语言处理OS信号采用复杂或冗余的方法，Golang内置OS包提供了易用的方法处理Unix信号，非常直接、简单。事实上，类unix系统中通常处理singal是必要的，本文介绍singal概念，并通过示例说明其应用场景。

从示例开始

假设场景：Golang应用在关闭时打印消息：“Thank you for using Golang.” 首先新建main函数，函数体模拟执行一些业务，直到接收到结束命令。

func main() {
   for {
      fmt.Println("Doing Work")
      time.Sleep(1 * time.Second)
   }
}

当运行应用，然后从OS发送执行kill信号（Ctrl + C），可能输出结果类似这样：

Doing Work
Doing Work
Doing Work
Process finished with exit code 2

现在我们希望拦截kill信号并定义处理逻辑：打印必要的关闭信息。

接收信号

首先创建channe接收来自操作系统的命令，os包提供了signal接口处理基于OS规范信号实现。

killSignal := make(chan os.Signal, 1)

为了通知killSignal，需使用signal包中提供的Notify函数，第一个参数为Signal类型的channel，下一个参数接收一组发给通道的信号列表。

Notify(c chan<- os.Signal, sig ...os.Signal)

我们也可以使用syscall包通知特定命令的信号：

signal.Notify(c chan<- os.Signal, syscall.SIGINT, syscall.SIGTERM)

为了处理信号，我们在main函数中使用killSignal通道等待interrupt信号，一旦接收到来自OS的命令，则打印结束消息并接收应用。现在把处理业务的循环代码移入独立的goroute中，这里定义一个匿名函数：

go func() {
   for {
      fmt.Println("Doing Work")
      time.Sleep(1 * time.Second)
   }
}()

因为业务代码运行在独立routine中，main函数实现等待killSignal信号并在结束之前打印消息。

<-killSignal
fmt.Println("Thanks for using Golang!")

完整代码

下面把几个部分组装在一起，完整代码如下：

package main

import (
	"fmt"
	"os"
	"os/signal"
	"time"
)

func main() {

	killSignal := make(chan os.Signal, 1)
	signal.Notify(killSignal, os.Interrupt)
	go func() {
		for {
			fmt.Println("Doing Work")
			time.Sleep(1 * time.Second)
		}
	}()
	<-killSignal
	fmt.Println("Thanks for using Golang!")
}

运行程序，看到一直执行业务循环，直到接收到interrupt信号，打印消息并结束：

Doing Work
Doing Work
Doing Work
Thanks for using Golang!

常见信号

对于命令行程序，当按CTRL+C时，会发送SIGINT信号，SIGINT是与指定特定信号数字相关联的名称。信号实际是可以有程序生成的软件中断，也是一种异步处理事件机制。通常为了安全起见，信号采用名称而不是数值生成。

大多数信号及其具体动作都是由操作系统定义的，并还在操作系统权限范围内执行相应功能。因此能够处理某些事件并不能让用户自由地使用系统，有些信号即使生成了也会被操作系统忽略，而由操作系统决定程序允许处理哪些信号。

举例，SIGKILL 和 SIGSTOP 信号也可以被捕获、阻塞或忽略。因为这些信号对于保持操作系统功能的"健全"至关重要，在极端条件下为内核和root用户提供了停止进程的方法。与SIGKILL相关联的数字是9，Linux提供了kill命令发送SIGTERM信号，终止正在运行的程序。可以使用kill -l命令查看完整的支持信号：

图片

有许多信号可用，但并非所有信号都能被程序处理。像SIGKILL和SIGSTOP这样的信号既不能被程序调用，也不能被程序忽略。原因很简单:它们太重要了，不允许被恶意程序滥用。

系统信号分为同步信号和异步信号。其中同步信号是程序执行中的错误触发的信号，如SIGBUS, SIGFPE, SIGSEGV，在 Golang 程序中，同步信号通常会被转换为 runtime panic。同步信号需要事件及事件时间，相反异步信号不需要于时钟同步，异步信号是系统内核或其它程序发送的信号。举例，SIGHUP表示它控制的终端被关闭，常用的是当按CTRL+C时，会发送SIGINT信号。当SIGINT信号有键盘产生时，实际上不是终止应用程序，而是生成特定键盘中断，并且处理该中断的程序开始执行，其缺省行为时关闭应用程序，但我们可以覆盖缺省行为，写我们自己的业务处理逻辑。

事实上许多信号处理都可以被覆盖，Go开发者可以编写自己的处理程序来自定义信号处理行为。然而，除非有非常好的理由，否则改变信号的默认行为并不是明智的想法。这里引用列举常用linux信号：

SIGHUP: ‘HUP’ = ‘hung up’. This signal is generated when a controlling process dies or hangs up detected on the controlling terminal.
SIGINT: When a process is interrupted from keyboard by pressing CTRL+C
SIGQUIT: Quit from keyboard
SIGILL: Illegal instruction. A synonym for SIGPWR() – power failure
SIGABRT: Program calls the abort() function – an emergency stop.
SIGBUS: Bad memory access. Attempt was made to access memory inappropriately
SIGFPE: FPE = Floating point exception
SIGKILL: The kill signal. The process was explicitly killed.
SIGUSR1: This signal is open for programmers to write a custom behavior.
SIGSEGV: Invalid memory reference. In C when we try to access memory beyond array limit, this signal is generated.
SIGUSR2: This signal is open for programmers to write a custom behavior.
SIGPIPE: This signals us open for programmers to write a custom behavior.
SIGALRM: Process requested a wake up call by the operating system such as by calling the alarm() function.
SIGTERM: A process is killed

处理多个信号

下面再看一个示例，较上面的示例增加了对SIGTERM信号的处理：

package main

import (
	"fmt"
	"os"
	"os/signal"
	"syscall"
)

func handler(signal os.Signal) {
	if signal == syscall.SIGTERM {
		fmt.Println("Got kill signal. ")
		fmt.Println("Program will terminate now.")
		os.Exit(0)
	} else if signal == syscall.SIGINT {
		fmt.Println("Got CTRL+C signal")
		fmt.Println("Closing.")
		os.Exit(0)
	} else {
		fmt.Println("Ignoring signal: ", signal)
	}
}

func main() {
	sigchnl := make(chan os.Signal, 1)
	signal.Notify(sigchnl)
    // signal.Notify(sigchnl, os.Interrupt, syscall.SIGTERM)
	exitchnl := make(chan int)

	go func() {
		for {
			s := <-sigchnl
			handler(s)
		}
	}()

	exitcode := <-exitchnl
	os.Exit(exitcode)
}

首先创建通道接收响应信号，我们也可以指定信号类型：signal.Notify(sigchnl, os.Interrupt, syscall.SIGTERM)，否则会接收所有信号，包括命令窗口改变大小信号。然后在handle函数判断信号类型并分别进行处理。

程序运行后，linux可以通过ps -h 查看go程序，然后执行kill命令。

NotifyContext示例

Go.1.16提供了signal.NotifyContext函数，可以实现更优雅的关闭功能。下面示例实现简单web服务器，示例handle需要10s处理时间，如果正在运行的web服务，客户端通过postman或cURL发送请求，然后在服务端立刻通过ctrl+C发送终止信号。
我们希望看到服务器在终止之前通过响应终止请求而优雅地关闭。如果关闭时间过长，可以发送另一个中断信号立即退出，或者暂停将在5秒后开始。

package main

import (
	"context"
	"fmt"
	"net/http"
	"os"
	"os/signal"
	"time"
)

var (
	server http.Server
)

func main() {
	// Create context that listens for the interrupt signal from the OS.
	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
	defer stop()

	server = http.Server{
		Addr: ":8080",
	}

	// Perform application startup.
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		time.Sleep(time.Second * 10)
		fmt.Fprint(w, "Hello world!")
	})

	// Listen on a different Goroutine so the application doesn't stop here.
	go server.ListenAndServe()

	// Listen for the interrupt signal.
	<-ctx.Done()

	// Restore default behavior on the interrupt signal and notify user of shutdown.
	stop()
	fmt.Println("shutting down gracefully, press Ctrl+C again to force")

	// Perform application shutdown with a maximum timeout of 5 seconds.
	timeoutCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	if err := server.Shutdown(timeoutCtx); err != nil {
		fmt.Println(err)
	}
}

总结

本文介绍了信号的概念及常用信号，并给出了应用广泛的几个示例，例如优雅地关闭应用服务、在命令行应用中接收终止命令。