拦截信号Golang应用优雅关闭的操作方法

目录

• 从示例开始
• 接收信号
• 常见信号
• 处理多个信号
• NotifyContext示例
• 总结

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信号并定义处理逻辑：打印必要的关闭信息。

接收信号

首先创建chan编程客栈ne接收来自操作系统的命令，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开发者可以编写自己的处理程序来自定义信号处理行为。然而，除非有非常好的理由，否则改变信号的默认行为并不是明智javascript的想法。这里引用列举常用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开发者_Python开发: 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.NotifyCo编程客栈ntext函数，可以实现更优雅的关闭功能。下面示例实现简单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 stopjs()

	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)
	}
}

总结

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

到此这篇关于拦截信号Golang应用优雅关闭的文章就介绍到这了,更多相关Golang关闭内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！