Wie entwickle ich einen Daemon-Prozess in der Go-Sprache?

Go-Sprache ist eine schnelle und effiziente Programmiersprache. Sie verfügt über gute Funktionen für die Entwicklung von Daemon-Prozessen, wie integrierte Parallelitätsunterstützung, leichtgewichtige Threads, Garbage-Collection-Mechanismus usw. Ein Daemon ist ein Programm, das im Hintergrund ausgeführt werden kann. Es muss normalerweise über einen längeren Zeitraum ausgeführt werden, wobei es ständig auf externe Ereignisse wie Netzwerkverbindungsanforderungen lauscht und die auftretenden Ereignisse entsprechend verarbeitet. In diesem Artikel wird vorgestellt, wie man Daemon-Prozesse in der Go-Sprache entwickelt.

1. Grundlegende Anforderungen des Daemon-Prozesses

In Linux- und Unix-Betriebssystemen muss ein Daemon-Prozess einige grundlegende Anforderungen erfüllen:

1. Dieser übergeordnete Prozess ist vorzugsweise ein Init-Prozess dass das System neu startet.
2. Der Daemon muss sich beim Start in den Hintergrund stellen und das steuernde Terminal freigeben.
3. Der Daemon muss in der Lage sein, Signale wie SIGTERM und SIGINT zu verarbeiten, um sich ordnungsgemäß zu bereinigen, wenn das System heruntergefahren oder beendet wird.

2. Schritte zum Implementieren eines Daemon-Prozesses

Die Entwicklung eines Daemon-Prozesses in der Go-Sprache erfordert die Durchführung der folgenden Schritte:

1. Erstellen Sie einen untergeordneten Prozess und beenden Sie den übergeordneten Prozess.
2. Rufen Sie die Funktion „setsid()“ auf, um einen neuen zu erstellen Sitzungsgruppe und Machen Sie den aktuellen Prozess zum Leiter der Sitzungsgruppe und zum einzigen Mitglied der neuen Prozessgruppe.
3. Schließen Sie die Dateideskriptoren 0, 1, 2 (Standardeingabe, Standardausgabe, Standardfehlerausgabe). Stammverzeichnis des Dateisystems (/), öffnen Sie seinen Dateideskriptor und verwenden Sie ihn dann als Arbeitsverzeichnis und Stammdateisystem des Prozesses.
4. Laden Sie die beim Start des Programms benötigten Ressourcen, einschließlich Konfigurationsdateien, Umgebungsvariablen usw . ;
5. Verarbeiten Sie SIGTERM- und SIGINT-Signale, um Programmressourcen korrekt zu bereinigen.
6. Im Folgenden stellen wir die konkrete Umsetzung dieser Schritte einzeln vor.

3. Implementierungsdetails

Erstellen Sie einen untergeordneten Prozess und beenden Sie den übergeordneten Prozess verarbeiten und den aktuellen Prozess verlassen, wodurch der neue Prozess zu einem untergeordneten Prozess des Daemons wird.

1. Erstellen Sie eine neue Konversationsgruppe

Das Codefragment zum Erstellen einer neuen Konversationsgruppe in der Go-Sprache lautet wie folgt:

func startDaemon() {
    cmd := exec.Command(os.Args[0])
    cmd.Start()
    os.Exit(0)
}

Dieser Code setzt zunächst die Dateiberechtigungsmaske auf 0 und prüft dann, ob der aktuelle Prozess bereits ausgeführt wird eine Konversationsgruppe Der führende Prozess (das heißt, ob der übergeordnete Prozess der Init-Prozess ist). In diesem Fall ist es nicht erforderlich, eine neue Konversationsgruppe zu erstellen. Andernfalls rufen Sie die oben erwähnte Funktion setsid() auf, um eine neue Sitzungsgruppe zu erstellen und den aktuellen Prozess zum Anführer der Sitzungsgruppe zu machen.

2. Schließen Sie den Dateideskriptor

In der Go-Sprache lautet der Codeausschnitt zum Schließen des Dateideskriptors wie folgt:

func startDaemon() {
    syscall.Umask(0)
    if syscall.Getppid() == 1 {
        return
    }
    cmd := exec.Command(os.Args[0])
    cmd.Start()
    os.Exit(0)
    ...
    sysret, syserr := syscall.Setsid()
    if syserr != nil || sysret < 0 {
        fmt.Fprintf(os.Stderr, "Error: syscall.Setsid errno:%d %v
", syserr, syserr)
        os.Exit(1)
    }
}

Dieser Code verwendet die Close()-Funktion im Syscall-Paket, um die Dateideskriptoren 0, 1, und 2.

3. Erstellen Sie ein beschreibbares Verzeichnis

Der Codeausschnitt zum Erstellen eines beschreibbaren Verzeichnisses in der Go-Sprache lautet wie folgt:

func startDaemon() {
    syscall.Umask(0)
    if syscall.Getppid() == 1 {
        return
    }
    cmd := exec.Command(os.Args[0])
    cmd.Start()
    os.Exit(0)
    ...
    syscall.Close(0)    // close stdin
    syscall.Close(1)    // close stdout
    syscall.Close(2)    // close stderr
}

Dieser Code ändert zunächst das aktuelle Arbeitsverzeichnis des Prozesses in das Stammverzeichnis (/) und verwendet es dann Das ioutil-Paket Die Funktion TempDir() erstellt ein neues Verzeichnis unter dem Verzeichnis /tmp. Als nächstes verwenden Sie die Funktion os.Open(), um das Verzeichnis zu öffnen und verwenden die Funktion Dup2() im Paket syscall, um dessen Dateideskriptoren in die Dateideskriptoren für Standardeingabe, Standardausgabe und Standardfehler zu kopieren.

4. Laden Sie die benötigten Ressourcen

Der Codeausschnitt zum Laden der benötigten Ressourcen kann in die Eingabefunktion des Programms geschrieben werden.

Verarbeitung von SIGTERM- und SIGINT-Signalen

Der Code für die Verarbeitung von SIGTERM- und SIGINT-Signalen in der Go-Sprache lautet wie folgt:

func startDaemon() {
    syscall.Umask(0)
    if syscall.Getppid() == 1 {
        return
    }
    cmd := exec.Command(os.Args[0])
    cmd.Start()
    os.Exit(0)
    ...
    os.Chdir("/")
    dir, _ := ioutil.TempDir("", "")
    fd, _ := os.Open(dir)
    syscall.Dup2(int(fd.Fd()), 0)
    syscall.Dup2(int(fd.Fd()), 1)
    syscall.Dup2(int(fd.Fd()), 2)
}

Dieser Code verwendet die Signal()-Funktion im Betriebssystempaket, um die SIGTERM- und SIGINT-Signale an a zu übertragen Pipeline bzw. zur Verarbeitung. Wenn Sie dann diese Pipe in einer anderen Goroutine abhören, können Sie Bereinigungsvorgänge durchführen, wenn diese Signale empfangen werden.

6. 4. Zusammenfassung

Dieser Artikel stellt vor, wie man Daemon-Prozesse in der Go-Sprache entwickelt. Ein Daemon-Prozess ist ein Programm mit langer Laufzeit, das verschiedene externe Ereignisse verarbeiten muss. Es muss einige grundlegende Anforderungen erfüllen, z. B. einen übergeordneten Prozess haben, sich beim Start in den Hintergrund stellen usw. Zu den Methoden zum Implementieren dieser Anforderungen in der Go-Sprache gehören das Erstellen eines untergeordneten Prozesses und das Beenden des übergeordneten Prozesses, das Erstellen einer neuen Sitzungsgruppe, das Schließen von Dateideskriptoren, das Erstellen eines beschreibbaren Verzeichnisses, das Laden erforderlicher Ressourcen sowie die Verarbeitung von SIGTERM- und SIGINT-Signalen. Nachdem wir diese Methoden beherrschen, können wir Daemon-Prozesse in der Go-Sprache frei entwickeln.

Das obige ist der detaillierte Inhalt vonWie entwickle ich einen Daemon-Prozess in der Go-Sprache?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!