什么是热重启

所谓热重启， 就是当关闭一个正在运行的进程时，该进程并不会立即停止，而是会等待所有当前逻辑继续执行完毕，才会中断。这就要求我们的服务需要支持一条重启命令，通过该命令可以重启服务，并同时保证重启过程中正在执行的逻辑不会中断，且重启后可以继续正常服务。

热重启的原理

热重启的原理会涉及到一些linux下系统调用以及进程之间socket句柄传递等细节，处理过程可以分为以下几个步骤：

1、监听重启信号 (SIGHUP)；

2、收到重启信号时fork子进程，同时需要将服务监听的socket文件描述符传递给子进程；

3、子进程接收并监听父进程传递的socket (这时候父进程和子进程都可以接收请求)；

4、等待子进程启动成功之后，停止父进程对新连接的接收 (父进程会等待旧连接逻辑处理完成)；

5、父进程退出，重启完成

实现代码如下：

 package main

import (
	"flag"
	"fmt"
	"golang.org/x/net/context"
	"io/ioutil"
	"log"
	"net"
	"net/http"
	"os"
	"os/exec"
	"os/signal"
	"strconv"
	"syscall"
	"time"
)

var (
	server   *http.Server
	listener net.Listener
	// 子进程的标志
	child = flag.Bool("child", false, "")
)

// init
func init() {
	updatePidFile()
}

// 更新pid文件
func updatePidFile() {
	oldPid := fmt.Sprint(os.Getpid())
	// 创建临时目录
	tmpDir := os.TempDir()
	// 判断进程是否启动
	if err := procExist(tmpDir); err != nil {
		fmt.Printf("pid file exists, update\n")
	} else {
		fmt.Printf("pid file NOT exists, create\n")
	}

	// 创建pid文件
	pidFile, _ := os.Create(tmpDir + "/gracefulRestart.pid")
	defer pidFile.Close()

	// 写入文件内容
	pidFile.WriteString(oldPid)
}

// 检查进程是否存在
func procExist(tmpDir string) (err error) {
	// 打开文件
	pidFile, err := os.Open(tmpDir + "/gracefulRestart.pid")
	defer pidFile.Close()
	if err != nil {
		return
	}

	// 读取文件内容
	filePid, err := ioutil.ReadAll(pidFile)
	if err != nil {
		return
	}

	pid, _ := strconv.Atoi(fmt.Sprintf("%s", filePid))
	// 查找pid进程
	if _, err = os.FindProcess(pid); err != nil {
		fmt.Printf("Failed to find process: %v\n", err)
		return
	}

	return
}

func main() {
	flag.Parse()

	// 启动监听
	http.HandleFunc("/hello", HelloHandler)
	server = &http.Server{Addr: ":8081"}

	var err error
	if *child { // 子进程
		fmt.Println("In Child, Listening...")

		f := os.NewFile(3, "")
		listener, err = net.FileListener(f)
	} else {
		fmt.Println("In Father, Listening...")

		listener, err = net.Listen("tcp", server.Addr)
	}
	if err != nil {
		fmt.Printf("Listening failed: %v\n", err)
		return
	}

	// go协程启动server
	go func() {
		err = server.Serve(listener)
		if err != nil {
			fmt.Printf("server.Serve failed: %v\n", err)
		}
	}()

	// 监听系统信号
	signalHandler()

	fmt.Printf("singalHandler end\n")
}

func HelloHandler(w http.ResponseWriter, r *http.Request) {
	//time.Sleep(30 * time.Second)
	for i := 0; i < 20; i++ {
		log.Printf("working %v\n", i)
		time.Sleep(1 * time.Second)
	}
	w.Write([]byte("hello world..."))
}

// 信号处理
func signalHandler() {
	ch := make(chan os.Signal, 1)
	signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP)

	for {
		sig := <-ch
		fmt.Printf("signal: %v\n", sig)

		ctx, _ := context.WithTimeout(context.Background(), 20*time.Second)
		switch sig {
		case syscall.SIGINT, syscall.SIGTERM: // 终止信号
			log.Printf("stop")
			signal.Stop(ch)
			server.Shutdown(ctx)
			fmt.Printf("graceful shutdown\n")
			return
		case syscall.SIGHUP: // 重启信号
			// reload
			log.Printf("restart")
			err := restart()
			if err != nil {
				fmt.Printf("graceful restart failed: %v\n", err)
			}

			// 更新当前pid文件
			updatePidFile()

			// golang >1.8，可以通过调用Golang中的Server.Shutdown()方法直接实现graceful stop
			// 老版本golang自己实现一个shutdown功能步骤：
			// 1、关闭listenr，停止接收新请求；
			// 2、通过sync.WaitGroup.wait()阻塞服务退出，从而实现等待其他逻辑的全部退出
			server.Shutdown(ctx)
			fmt.Printf("graceful reload\n")
			return
		}
	}
}

// 重启
func restart() error {
	// 提取文件描述符
	tl, ok := listener.(*net.TCPListener)
	if !ok {
		return fmt.Errorf("listener is not tcp listener")
	}
	f, err := tl.File()
	if err != nil {
		return err
	}

	// 创建子进程，同时传递了child参数到子进程中，从而可以执行在进程监听时走子进程创建socket的流程。
	args := []string{"-child"}
	cmd := exec.Command(os.Args[0], args...)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	// cmd的ExtraFiles参数会将额外的文件描述符传递给继承的新进程(不包括标准输入、标准输出和标准错误)
	// 父进程传递listener的fd给子进程，而子进程里0、1、2是预留给标准输入、输出和错误的，所以父进程给的第一个fd在子进程里顺序排就是从3开始，
	// 即上文中的os.NewFile(3,"")中3的由来
	cmd.ExtraFiles = []*os.File{f}
	return cmd.Start()
}  

测试：

 $ go run main.go
pid file NOT exists, create
In Father, Listening... // 父进程启动
2022/01/21 17:42:21 working 0
2022/01/21 17:42:22 working 1
2022/01/21 17:42:23 working 2
2022/01/21 17:42:24 working 3
2022/01/21 17:42:25 working 4
2022/01/21 17:42:26 working 5
2022/01/21 17:42:27 working 6
2022/01/21 17:42:28 working 7
2022/01/21 17:42:29 working 8
2022/01/21 17:42:30 working 9
2022/01/21 17:42:31 working 10
2022/01/21 17:42:32 working 11
2022/01/21 17:42:33 working 12
2022/01/21 17:42:34 working 13
2022/01/21 17:42:35 working 14
2022/01/21 17:42:36 working 15 // 执行到这里时进行重启

# 通过端口号8081查看对应的pid
$ lsof -i :8081
COMMAND   PID  USER   FD   TYPE             DEVICE SIZE/OFF NODE NAME
main    79963 admin    3u  IPv6 0xeacf6c71139ace71      0t0  TCP *:sunproxyadmin (LISTEN)

# 重启(发送 SIGHUP 信号)
$ kill -HUP 79963
signal: hangup
2022/01/21 17:42:36 restart
pid file NOT exists, create
server.Serve failed: http: Server closed
pid file NOT exists, create
In Child, Listening... // 子进程启动
2022/01/21 17:42:37 working 16 // 重启成功后，继续执行，不中断
2022/01/21 17:42:38 working 17
2022/01/21 17:42:39 working 18
2022/01/21 17:42:40 working 19
graceful reload
singalHandler end