Golang

关注公众号 jb51net

关闭
首页 > 脚本专栏 > Golang > Go语言优雅关闭程序

详解Go语言如何热重载和优雅地关闭程序

作者：242030

我们有时会因不同的目的去关闭服务，一种关闭服务是终止操作系统，一种关闭服务是用来更新配置，本文就来和大家简单讲讲这两种方法的实现吧

我们有时会因不同的目的去关闭服务，一种关闭服务是终止操作系统，一种关闭服务是用来更新配置。

我们希望优雅地关闭服务和通过热重载重新加载配置，而这两种方式可以通过信号包来完成。

1、代码实现

package main
import (
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"
)
type Config struct {
	Message string
}
var conf = &Config{Message: "Before hot reload"}
func router() {
	log.Println("starting up....")
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		_, _ = w.Write([]byte(conf.Message))
	})
	go func() {
		log.Fatal(http.ListenAndServe(":8080", nil))
	}()
}
func main() {
	router()
	sigCh := make(chan os.Signal, 1)
	signal.Notify(sigCh, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM)
	for {
		multiSignalHandler(<-sigCh)
	}
}
func multiSignalHandler(signal os.Signal) {
	switch signal {
	case syscall.SIGHUP:
		log.Println("Signal:", signal.String())
		log.Println("After hot reload")
		conf.Message = "Hot reload has been finished."
	case syscall.SIGINT:
		log.Println("Signal:", signal.String())
		log.Println("Interrupt by Ctrl+C")
		os.Exit(0)
	case syscall.SIGTERM:
		log.Println("Signal:", signal.String())
		log.Println("Process is killed.")
		os.Exit(0)
	default:
		log.Println("Unhandled/unknown signal")
	}
}

首先，定义了一个 Config 结构并声明了一个 conf 变量。

type Config struct {
	Message string
}
var conf = &Config{Message: "Before hot reload"}

这里的代码只是一个简单的配置样本，你可以根据自己的需要定义一个复杂的结构。

其次，定义一个路由器函数，用来绑定和监听 8080 端口。在热重载配置完成后，它也被用来显示结果。

func router() {
    log.Println("starting up....")
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        _, _ = w.Write([]byte(conf.Message))
    })
    go func() {
        log.Fatal(http.ListenAndServe(":8080", nil))
    }()
}

下一步是服务器关机和热重载配置，当一个服务器关闭时，它应该停止接收新的请求，同时完成正在进行的请求，

返回其响应，然后关闭，在这里使用信号包实现。

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

之后，使用 signal.Notify() 一起发送更多的信号。

signal.Notify(sigCh, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM)

当程序被中断时，signal.Notify 将向 sigCh 通道发送一个信号。

syscall.SIGHUP、syscall.SIGINT 和 syscall.SIGTERM 是什么意思?

如何优雅地关闭，multiSignalHandler(<-sigCh) 被用来接收 chan 值，然后它将决定运行代码的哪一部分。

func multiSignalHandler(signal os.Signal) {
    switch signal {
    case syscall.SIGHUP:
        log.Println("Signal:", signal.String())
        log.Println("After hot reload")
        conf.Message = "Hot reload has been finished."
    case syscall.SIGINT:
        log.Println("Signal:", signal.String())
        log.Println("Interrupt by Ctrl+C")
        os.Exit(0)
    case syscall.SIGTERM:
        log.Println("Signal:", signal.String())
        log.Println("Process is killed.")
        os.Exit(0)
    default:
        log.Println("Unhandled/unknown signal")
    }
}

2、测试优雅关闭

首先，运行服务器。

$ go run main.go
2023/06/25 09:57:05 starting up....

发送一个curl请求。

$ curl localhost:8080
Before hot reload

先用Ctrl+C测试一下中断。

$ go run main.go
2023/06/25 09:57:05 starting up....
2023/06/25 09:59:45 Signal: interrupt
2023/06/25 09:59:45 Interrupt by Ctrl+C

3、热重载

首先，运行服务器。

$ go run main.go
2023/06/24 22:03:17 starting up....

然后，发送curl请求。

$ curl localhost:8080
Before hot reload

查看进程：

$ lsof -i tcp:8080
COMMAND   PID USER   FD   TYPE   DEVICE SIZE/OFF NODE NAME
main    85193 root    3u  IPv6 13642377      0t0  TCP *:webcache (LISTEN)

使用 kill 杀死进程：

$ kill -SIGHUP 85193

$ go run main.go
2023/06/24 22:03:17 starting up....
2023/06/24 22:06:05 Signal: hangup
2023/06/24 22:06:05 After hot reload

如果直接使用 kill 命令杀死程序：

$ go run main.go
2023/06/24 22:14:11 starting up....

$ lsof -i tcp:8080
COMMAND   PID USER   FD   TYPE   DEVICE SIZE/OFF NODE NAME
main    89619 root    3u  IPv6 13669401      0t0  TCP *:webcache (LISTEN)

$ kill -9 89619

$ go run main.go
2023/06/24 22:14:11 starting up....
2023/06/24 22:14:50 Signal: terminated
2023/06/24 22:14:50 Process is killed.

4、Go信号库os/signal

在官方介绍中，这个库主要封装信号实现对输入信号的访问，信号主要用于类 Unix 系统。

信号是事件发生时对进程的通知机制，有时也称之为软件中断。信号与硬件中断的相似之处在于打断了程序执行的正常流程，大多数情况下，无法预测信号到达的精确时间。

因为一个具有合适权限的进程可以向另一个进程发送信号，这可以称为进程间的一种同步技术。当然，进程也可以向自身发送信号。然而，发往进程的诸多信号，通常都是源于内核。引发内核为进程产生信号的各类事件如下：

硬件发生异常，即硬件检测到一个错误条件并通知内核，随即再由内核发送相应信号给相关进程。比如执行一条异常的机器语言指令(除0，引用无法访问的内存区域)。

用户键入了能够产生信号的终端特殊字符。如中断字符 (通常是 Control-C)、暂停字符(通常是 Control-Z)。

发生了软件事件。如调整了终端窗口大小，定时器到期等。

4.1 举例说明

package main
import (
	"fmt"
	"os"
	"os/signal"
	"syscall"
)
func main() {
	// os.Signal是一个系统信号接收channel
	c := make(chan os.Signal, 1)
	// syscall都是一些系统信号
	signal.Notify(c, syscall.SIGHUP, syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT)
	for {
		s := <-c
		fmt.Printf("get a signal %s", s.String())
		switch s {
		case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT:
			fmt.Printf("exit")
			os.Exit(0)
		case syscall.SIGHUP:
			fmt.Printf("reload")
		default:
			fmt.Printf("nothing")
		}
	}
}

1、首先初始化一个 os.Signal 类型的 channel，我们必须使用缓冲通道，否则在信号发送时如果还没有准备好接收信号，就有丢失信号的风险。

2、signal.notify 用于监听信号，参数1表示接收信号的 channel，参数2及后面的表示要监听的信号：

3、<-c 一直阻塞直到接收到信号退出。

对于上面的的程序是优雅的退出守护进程，接下来就是一些释放资源或dump进程当前状态或记录日志的动作，完成这些后，主进程退出。

4.2 GO的信号类型

4.2.1 POSIX.1-1990标准中定义的信号列表

4.2.2 在SUSv2和POSIX.1-2001标准中的信号列表

信号 SIGKILL 和 SIGSTOP 可能不会被程序捕获，因此不会受此软件包影响。

同步信号是由程序执行中的错误触发的信号：SIGBUS，SIGFPE 和 SIGSEGV。这些只在程序执行时才被认为是同步的，而不是在使用 os.Process.Kill 或 kill 程序或类似的机制发送时。一般来说，除了如下所述，Go 程序会将同步信号转换为运行时异常。其余信号是异步信号，它们不是由程序错误触发的，而是从内核或其他程序发送的。

在异步信号中，SIGHUP 信号在程序失去其控制终端时发送。当控制终端的用户按下中断字符(默认为^ C

(Control-C))时，发送 SIGINT 信号。当控制终端的用户按下退出字符时发送 SIGQUIT 信号，默认为^ \

(Control-Backslash)。一般情况下，您可以通过按^ C来使程序简单地退出，并且可以通过按^使堆栈转储退出。

4.3 Kill命令的原理

我们平时在 Linux 系统会 kill 命令来杀死进程，那其中的原理是什么呢。

4.3.1 kill pid

kill pid 的作用是向进程号为 pid 的进程发送 SIGTERM (这是 kill 默认发送的信号)，该信号是一个结束进程的信号且可以被应用程序捕获。若应用程序没有捕获并响应该信号的逻辑代码，则该信号的默认动作是 kill 掉进程。这是终止指定进程的推荐做法。

4.3.2 kill -9 pid

kill -9 pid 则是向进程号为 pid 的进程发送 SIGKILL (该信号的编号为9)，从本文上面的说明可知，SIGKILL 既不能被应用程序捕获，也不能被阻塞或忽略，其动作是立即结束指定进程。通俗地说，应用程序根本无法感知 SIGKILL信号，它在完全无准备的情况下，就被收到 SIGKILL 信号的操作系统给干掉了，显然，在这种暴力情况下，应用程序完全没有释放当前占用资源的机会。事实上，SIGKILL 信号是直接发给 init 进程的，它收到该信号后，负责终止 pid 指定的进程。在某些情况下(如进程已经 hang 死，无响应正常信号)，就可以使用 kill -9 来结束进程。

到此这篇关于详解Go语言如何热重载和优雅地关闭程序的文章就介绍到这了,更多相关Go语言优雅关闭程序内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文