Comment Golang crée un processus démon et redémarre en douceur

La colonne tutorielle suivante de golang vous présentera comment créer un processus démon et redémarrer en douceur dans Golang. J'espère qu'elle sera utile aux amis dans le besoin !

En tant que vétéran du développement PHP. Utilisé la ligne de commande pour démarrer/redémarrer/arrêter des opérations telles que nginx et PHP-FPM. Très impressionné. Si on me demandait de développer un tel système en C/C++, je n’aurais certainement pas l’énergie pour le faire. Cependant, depuis que Golang est entré dans mon champ de vision. J'ai trouvé tout cela très facile.

1) Générer un processus démon

Aller directement au 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
    }
}

Les personnes familiarisées avec les systèmes Linux doivent le savoir : le processus démon créé par l'utilisateur sera utilisé par le processus Le n°1 du système Linux prend le relais. En d’autres termes, le code ci-dessus ne peut s’exécuter que sur les systèmes Linux. Je n'ai jamais joué avec les systèmes Unix. Je ne peux donc pas donner de suggestions spécifiques.

J'ai vu sur Internet qu'il existe d'autres façons de créer un démon. Cependant, je pense que seule la méthode du code source ci-dessus me semble bonne. et utilisé avec succès dans des projets.

Par exemple :

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

Seul exec.Command est le moyen le plus avancé de créer un démon. Mieux encore encapsulé. Il est recommandé d'utiliser ce test.

2) Démarrage/redémarrage/arrêt du démon

Au point 1, nous avons démarré avec succès un démon. Cependant, nous ne pouvons pas utiliser la commande kill pour y mettre fin. Ensuite, redémarrez-le. Nous devons donc utiliser l’approche professionnelle de l’industrie : les signaux.

Tout processus en cours d'exécution peut recevoir le signal que nous lui envoyons. Il existe de nombreux signaux concernant Linux. Vous pouvez rechercher sur Google le mot-clé : signal Linux.

Allez directement au code source :

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")
}

Il y a trois points clés :
1) Enregistrez le signal
2) Recevez le signal
3) Processez le signal.

Tant que la création du processus démon et le traitement du sémaphore sont intégrés, des commandes peuvent être implémentées pour gérer le processus démon.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!