守护进程只执行一次 goroutine

Question

我尝试添加必要的代码来像守护程序一样执行我的应用程序。我用了下一个项目：

• github.com/sevlyar/go-daemon

我重写了已完成的示例 go 代码： https://github.com/sevlyar/go-daemon/blob/master/sample/sample.go

package main

import (
    "bufio"
    "flag"
    "fmt"
    "io/ioutil"
    "os"
    "syscall"
    "time"

    "github.com/sevlyar/go-daemon"
)

var (
    signal = flag.String("s", "", `sdaemon -s ...
        quit -- graceful shutdown`)
)

var (
    stop = make(chan struct{})
    done = make(chan struct{})
)

func main() {
    flag.Parse()
    daemon.AddCommand(daemon.StringFlag(signal, "quit"), syscall.SIGQUIT, TermHandler)

    cntxt := &daemon.Context{
        PidFileName: "/var/run/sdaemon.pid",
        PidFilePerm: 0644,
        WorkDir:     "./",
        Umask:       027,
        Args:        []string{"[sdaemon]"},
    }
    if len(daemon.ActiveFlags()) > 0 {
        d, _ := cntxt.Search()
        daemon.SendCommands(d)
        return
    }
    d, err := cntxt.Reborn()
    if d != nil {
        return
    }
    if err != nil {
        os.Exit(1)
    }
    defer cntxt.Release()

    // Start daemon
    go Worker()

    err = daemon.ServeSignals()
    if err != nil {
        fmt.Printf("STOPPED!\n")
        return
    }
}

func Worker() {
    for {
        go Writer()
        if _, ok := <-stop; ok {
            break
        }
    }
    done <- struct{}{}
}

func TermHandler(sig os.Signal) error {
    stop <- struct{}{}
    if sig == syscall.SIGQUIT {
        <-done
    }
    return daemon.ErrStop
}

我添加了一个函数Writer()，它读取文件，将文本保留为字符串，并使用此字符串创建一个新文件。

func Writer() error {
    time.Sleep(time.Minute)

    f, _ := ioutil.ReadFile("$HOME/test")
    contents := string(f)

    fileHandle, _ := os.Create("$HOME/stest")
    writer := bufio.NewWriter(fileHandle)
    defer fileHandle.Close()
    fmt.Fprintln(writer, contents)
    writer.Flush()

    return nil
}

我在golang中处理的通道不是很好，我不知道为什么Worker()函数中的无限循环只执行一次......

你能帮帮我吗？

Answer 1

问题出在Worker 函数中，当您尝试检查done 通道中是否有任何数据时。 receivecall 将阻塞，直到有要读取的值，因此该调用将阻塞，直到您向进程发送信号。

接收操作符返回的第二个值ok 并不表示一个值是否被成功读取。它只是指示在尝试接收值时通道是否已关闭（如果是，则返回 zero value，请参阅 the specification）。

要检查通道中是否有值，您需要使用select 语句，如下所示：

select {
        case v, ok <- stop:
            // We could read a value from the channel
        default:
            // No value could be read, but we didn't block
}

所以你的Worker 函数应该类似于：

func Worker() {
    for {
        time.Sleep(time.Minute)
        select {
        case <- stop:
            // Got a stop signal, stopping
            done <- struct{}{}
            return
        default:
            // No stop signal, continuing loop
        }

        go Writer()
    }
}

请注意，我已将 Sleep 从 Writer 函数移至 Worker，否则您最终会得到数千个并发 Writer go-routines...