Wie Golang einen Daemon-Prozess erstellt und reibungslos neu startet

Die folgende Tutorial-Kolumne von golang zeigt Ihnen, wie Sie einen Daemon-Prozess erstellen und in Golang reibungslos neu starten. Ich hoffe, dass es für Freunde in Not hilfreich ist!

Als PHP-Entwicklungsveteran. Verwendet die Befehlszeile zum Starten/Neustarten/Stoppen von Vorgängen wie Nginx und PHP-FPM. Sehr beeindruckt. Wenn ich gebeten würde, ein solches System mit C/C++ zu entwickeln, hätte ich definitiv nicht die Energie dazu. Allerdings trat Golang in mein Blickfeld. Ich fand es alles sehr einfach.

1) Daemon-Prozess generieren

Gehe direkt zum Code:

package main

import (
    "os"
    "os/exec"
    "path/filepath"
)

func main() {
    //判 断当其是否是子进程，当父进程return之后，子进程会被 系统1 号进程接管
    if os.Getppid() != 1 {
        // 将命令行参数中执行文件路径转换成可用路径
        filePath, _ := filepath.Abs(os.Args[0])
        cmd := exec.Command(filePath, os.Args[1:]...)
        // 将其他命令传入生成出的进程
        cmd.Stdin = os.Stdin // 给新进程设置文件描述符，可以重定向到文件中
        cmd.Stdout = os.Stdout
        cmd.Stderr = os.Stderr
        cmd.Start() // 开始执行新进程，不等待新进程退出
        return
    }
}

Wer sich mit Linux-Systemen auskennt, sollte wissen, dass der vom Benutzer erstellte Daemon-Prozess vom Prozess Nr. 1 des Linux-Systems übernommen wird. Mit anderen Worten: Der obige Code kann nur auf Linux-Systemen ausgeführt werden. Ich habe noch nie mit Unix-Systemen gespielt. Daher kann ich keine konkreten Vorschläge machen.

Ich habe im Internet gesehen, dass es andere Möglichkeiten gibt, einen Daemon zu erstellen. Ich denke jedoch, dass mir nur die obige Quellcode-Methode gut erscheint. und erfolgreich in Projekten eingesetzt.

Zum Beispiel:

os.StartProcess() 创建守护进程。
syscall.RawSyscall() 创建守护进程。

Nur exec.Command ist die fortschrittlichste Möglichkeit, einen Daemon zu erstellen. Am besten gekapselt. Es wird empfohlen, diesen Test zu verwenden.

2) Daemon starten/neu starten/stoppen

In Punkt 1 haben wir erfolgreich einen Daemon gestartet. Allerdings können wir den Kill-Befehl nicht verwenden, um es zu beenden. Dann starten Sie es erneut. Deshalb müssen wir den professionellen Ansatz der Branche nutzen: Signale.

Jeder laufende Prozess kann das Signal empfangen, das wir an ihn senden. Es gibt viele Signale über Linux. Sie können bei Google nach dem Stichwort „Linux-Signal“ suchen.

Gehen Sie direkt zum Quellcode:

package main

import "fmt"
import "os"
import "os/signal"
import "syscall"

func main() {

    // Go signal notification works by sending `os.Signal`
    // values on a channel. We'll create a channel to
    // receive these notifications (we'll also make one to
    // notify us when the program can exit).
    sigs := make(chan os.Signal, 1)
    done := make(chan bool, 1)

    // `signal.Notify` registers the given channel to
    // receive notifications of the specified signals.
    signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)

    // This goroutine executes a blocking receive for
    // signals. When it gets one it'll print it out
    // and then notify the program that it can finish.
    go func() {
        sig := <-sigs
        fmt.Println()
        fmt.Println(sig)
        done <- true
    }()

    // The program will wait here until it gets the
    // expected signal (as indicated by the goroutine
    // above sending a value on `done`) and then exit.
    fmt.Println("awaiting signal")
    <-done
    fmt.Println("exiting")
}

Es gibt drei wichtige Punkte:
1) Registrieren Sie das Signal
2) Empfangen Sie das Signal
3) Verarbeiten Sie das Signal.

Solange die Erstellung des Daemon-Prozesses und die Semaphorverarbeitung integriert sind, können Befehle zur Verwaltung des Daemon-Prozesses implementiert werden.

Das obige ist der detaillierte Inhalt vonWie Golang einen Daemon-Prozess erstellt und reibungslos neu startet. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!