Contrôle de processus et gestion des signaux en langage Go

Le langage Go est un langage de programmation open source. Il est de plus en plus populaire parmi les programmeurs en raison de sa simplicité, de sa facilité d'utilisation, de son efficacité et de sa sécurité. Dans le langage Go, le contrôle de processus et le traitement du signal sont également des éléments très importants. Cet article approfondira le contrôle de processus et le traitement du signal dans le langage Go.

Appel de processus en langage Go

Le contrôle de processus en langage Go peut réaliser l'appel et le contrôle entre plusieurs processus. Le langage Go fournit la bibliothèque os et la bibliothèque exec, qui peuvent démarrer et appeler des processus. En appelant la ligne de commande dans la bibliothèque os, vous pouvez créer un nouveau processus et lier sa sortie au flux de sortie standard du processus en cours. Vous pouvez également importer le flux d'entrée standard du processus en cours dans le processus nouvellement créé.

En langage Go, la fonction os.StartProcess() est principalement utilisée pour créer un nouveau processus. Le prototype de cette fonction est le suivant :

func StartProcess(name string, args []string, attr os.ProcAttr) (os.Process, error)

Parmi eux, le paramètre name représente le chemin du fichier exécutable de le nouveau processus ; le paramètre args Est le paramètre de ligne de commande à transmettre au nouveau processus ; le paramètre attr peut être utilisé pour spécifier les attributs du nouveau processus, tels que les variables d'environnement et le répertoire de travail.

L'exemple de code pour démarrer un processus est le suivant :

package main

import (
    "fmt"
    "os"
)

func main() {
    cmd := exec.Command("ls", "-l")
    output, err := cmd.Output()
    if err != nil {
        panic(err)
    }
    fmt.Println(string(output))
}

Dans cet exemple, nous démarrons la commande ls en appelant la fonction Command(), lions sa sortie au flux de sortie standard du processus en cours, et enfin appelons Output ( ) pour lire la sortie et l'imprimer à l'écran.

Traitement du signal

Le signal est un mécanisme de communication inter-processus, qui permet au système d'exploitation d'envoyer un signal spécifique au processus, et le processus peut le gérer en conséquence. Dans le langage Go, vous pouvez utiliser les fonctions Signal et Signal.Notify de la bibliothèque os pour enregistrer et gérer les signaux.

La fonction Signal est utilisée pour renvoyer un objet signal d'un signal spécifié. Son prototype est le suivant :

func Signal(sig syscall.Signal) Signal

Parmi eux, le paramètre sig spécifie un signal correspondant au numéro d'appel système. . Par exemple, SIGINT représente un signal d'interruption. L'objet Signal renvoyé peut être utilisé, par exemple, en utilisant la méthode Wait pour attendre l'arrivée du signal.

La fonction Notify est utilisée pour enregistrer la fonction de traitement du signal du processus. Lorsqu'un signal spécifié arrive, la fonction correspondante sera appelée pour le traitement. Le prototype de la fonction est le suivant :

func Notify(c chan<- os.Signal, sig ...os.Signal)

Parmi eux, le paramètre c est le canal utilisé pour recevoir les signaux entrants, et le paramètre sig spécifie l'objet signal qui doit être enregistré. L'exemple de code est le suivant :

package main

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

func main() {
    c := make(chan os.Signal, 1)
    signal.Notify(c, syscall.SIGINT, syscall.SIGTERM)
    go func() {
        s := <-c
        fmt.Println("received signal:", s)
        os.Exit(1)
    }()

    fmt.Println("Start working...")
    for {
        fmt.Println("working...")
        time.Sleep(time.Second * 1)
    }
}

Dans l'exemple de programme ci-dessus, nous ajoutons les signaux SIGINT et SIGTERM au pipeline de signaux en appelant la fonction Notify. Lorsque le signal d'attente est reçu, le programme se termine immédiatement. Grâce au traitement du signal, nous pouvons contrôler le déroulement et la fin du programme de manière très flexible.

Résumé

Cet article présente le contrôle de processus et le traitement du signal dans le langage Go. Dans le langage Go, le démarrage et le contrôle du processus peuvent être réalisés en appelant la bibliothèque os et la bibliothèque exec, et la communication inter-processus peut également être réalisée via le traitement du signal. mécanisme et contrôle. La maîtrise du contrôle des processus et du traitement du signal nous permet de contrôler avec plus de flexibilité le déroulement et la sortie du programme.

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!