Golang学习之平滑重启

在Golang开发中，应用程序的重启不可避免，常见的复杂业务流程、数据库链接等，都需要重新加载。但是，重新加载会影响应用程序的服务质量，我们期望实现一个“无感知”的平滑重启，本文将介绍Golang平滑重启的实现。

攻略

实现Golang平滑重启需要使用到以下几个步骤：

1. 父进程监听

在平滑重启的实现中，我们使用父进程来监听各个子进程，实现平滑重启的主要思路就是创建新的子进程，在新的子进程启动并监听端口前，保持原有子进程的服务不中断，等新的子进程启动完成后再把监听端口的文件描述符从旧的子进程传递给新的子进程。

func ForkParent() {
    go func() {
        listener, err := net.Listen("tcp", ":8080")
        if err != nil {
            log.Fatalln("Failed to listen:", err)
        }

        for {
            conn, err := listener.Accept()
            if err != nil {
                log.Fatalln("Failed to accept:", err)
            }

            // 传递文件描述符
            syscall.Sendmsg(child, []byte{0}, syscall.UnixRights(int(file.Fd())), nil, 0)
            runtime.Gosched()
            _ = conn.Close()
        }
    }()
}

2. 子进程监听

父进程监听子进程的状态，如果发生SIGUSR2信号，说明需要创建新的子进程。

func ForkChild() {
    go func() {
        // block for the first connection to create a new parent
        for {
            syscall.Recvmsg(uintptr(0), nil, nil, 0)
            err := reload()
            log.Println("reload error:", err)
        }
    }()
}

func reload() error {
    // 在进程启动时，需要打开监听
    listener, err := net.Listen("tcp", ":8080")
    if err != nil {
        log.Println("Failed to listen:", err)
        return err
    }

    // 启动协程监听请求，业务逻辑自行实现
    go func() {
        for {
            conn, err := listener.Accept()
            if err != nil {
                log.Fatalln("Fail to accept:", err)
            }

            go handle(conn)
        }
    }()

    return nil
}

3. 信号处理

在SIGUSR2信号处理函数中，启动子进程并传递文件描述符，原有子进程进行退出，由新的子进程接管工作。

func sigusr2() {
    child, err := StartChild()
    if err != nil {
        log.Fatalln(err)
    }
    defer child.Closer()

    for {
        awaitSignal()
        // 在父进程中传递文件描述符
        syscall.Sendmsg(child.Pipe, []byte{0}, syscall.UnixRights(int(listenerFd)), nil, 0)
    }
}

func awaitSignal() {
    // signal handler only to awaken blocked recevmsg
    c := make(chan os.Signal, 1)
    signal.Notify(c, syscall.SIGUSR2)
    <-c
    signal.Stop(c)
}

示例

这里提供两个代码示例：

示例1：基础版

func main() {
    ForkParent()
    ForkChild()
    sigusr2()
    // 业务逻辑自行实现
}

示例2：高级版

在示例1的基础上，增加了优雅退出的实现，保证子进程能够优雅关闭。

func main() {
    ForkParent()
    ForkChild()

    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGTERM)
    signal.Notify(quit, syscall.SIGINT)
    signal.Notify(quit, syscall.SIGQUIT)
    defer signal.Stop(quit)

    go func() {
        for {
            select {
            case <-quit:
                // 优雅关闭，等待子进程处理完请求再关闭
                if err := StopChild(child); err != nil {
                    log.Fatalln(err)
                }
                os.Exit(0)
            }
        }
    }()

    sigusr2()
    // 业务逻辑自行实现
}

结语

本文介绍了Golang平滑重启的基本思路和实现攻略，同时提供了代码示例。实现平滑重启需要注意文件描述符的传递、信号的处理等问题，能够灵活运用这些技巧，就可以实现Golang应用程序的无感知平滑重启。