去信号处理

Question

我是 Go 的新手，一直在尝试弄清楚如何处理需要返回主循环的事件。

在 C 中，我可以只返回函数，但我似乎不能在这里这样做，至少不能用那个方法。

我可以处理需要在 sigHandler() 内处理的信号，即 SIGINT 或 SIGTERM，但在处理 SIGHUP 或 SIGUSR 时，我需要将调用返回给 main。在我下面的代码中，一旦我发送挂断信号，进程就停留在等待模式。

如果有人可以帮助我指导我如何正确设计信号处理以处理需要返回到第一个 goroutine 中的主代码的调用，我将不胜感激。

编辑

我现在正在 select{} 内的主 goroutine 中处理 channel 消息，但是当我发送 HUP 信号时，下面的代码会退出。这里的目标是重新加载配置并继续正常执行。

在主线代码中，我有这个:

go sigHandler()
cs := make(chan bool, 1)
go sigHandler(cs)

// setup the http server
err := setupServer(addr, port)
if err != nil {
    fatal("Error setting up listening sockets")
    os.Exit(1)
}

    select {
    case quit := <-cs:
        if quit {
            logEvent(loginfo, sys, "Terminating..")
            closeLog()
            os.Exit(0)
        } else {
            logEvent(loginfo, sys, "Reloading configuration..")
            }
    }

函数 sigHandler()

func sigHandler(cs chan bool) {
    c := make(chan os.Signal, 1)
    signal.Notify(c, syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP)

    signal := <-c
    logEvent(lognotice, sys, "Signal received: "+signal.String())

    switch signal {
    case syscall.SIGINT, syscall.SIGTERM:
        cs <- true
    case syscall.SIGHUP:
            cs <- false
    }
}

Answer 1

你可以这样做:

package main

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

// We make sigHandler receive a channel on which we will report the value of var quit
func sigHandler(q chan bool) {
        var quit bool

        c := make(chan os.Signal, 1)
        signal.Notify(c, syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP)

        // foreach signal received
        for signal := range c {
                //      logEvent(lognotice, sys, "Signal received: "+signal.String())

                switch signal {
                case syscall.SIGINT, syscall.SIGTERM:
                        quit = true
                case syscall.SIGHUP:
                        quit = false
                }

                if quit {
                        quit = false
                        //              closeDb()
                        //              logEvent(loginfo, sys, "Terminating..")
                        //              closeLog()
                        os.Exit(0)
                }
                // report the value of quit via the channel
                q <- quit
        }
}

func main() {
        // init two channels, one for the signals, one for the main loop
        sig := make(chan bool)
        loop := make(chan error)

        // start the signal monitoring routine
        go sigHandler(sig)


        // while vat quit is false, we keep going
        for quit := false; !quit; {
                // we start the main loop code in a goroutine
                go func() {
                        // Main loop code here
                        // we can report the error via the chan (here, nil)
                        loop <- nil
                }()

                // We block until either a signal is received or the main code finished
                select {
                // if signal, we affect quit and continue with the loop
                case quit = <-sig:
                // if no signal, we simply continue with the loop
                case <-loop:
                }
        }
}

但是请注意，信号会导致主循环继续，但不会停止第一个 goroutine 的执行。