golang ferme d'autres programmes

J'apprenais le golang récemment et j'ai rencontré une exigence : pendant l'exécution du programme, d'autres programmes spécifiés dans le système doivent être fermés pour garantir l'exactitude du programme. Afin de répondre à cette exigence, j'ai mené quelques recherches et donné les méthodes suivantes.

Méthode 1 : exec.Command

Il existe un package exec dans golang, à travers lequel une commande externe peut être exécutée, ce qui signifie que d'autres programmes peuvent être exécutés via golang programme. Sur la base de cette fonctionnalité, nous pouvons utiliser la méthode exec.Command pour fermer d'autres programmes spécifiés.

Exemple de code :

cmd := exec.Command("taskkill", "/F", "/IM", "notepad.exe")
err := cmd.Run()
if err != nil {
    fmt.Println("execute command failed: ", err)
}

Le code ci-dessus exécute la commande taskkill sous le système Windows via la méthode exec.Command pour fermer le programme notepad.exe. Parmi eux, /F signifie mettre fin de force au processus, et /IM est suivi du nom du processus.

Ensuite, nous analysons la méthode d'exécution de exec.Command en fonction du code :

1. Créez d'abord l'objet de structure exec.Cmd cmd.
2. Définissez la commande et les paramètres à exécuter (PID ou nom de l'image du processus dans le Gestionnaire des tâches).
3. Appelez la méthode cmd.Run() pour exécuter la commande.
4. Gérez l'erreur err renvoyée par cmd.Run(). Si err n'est pas nul, cela signifie que l'exécution de la commande a échoué.

Méthode 2 : syscall.Kill

En plus d'utiliser le package exec pour exécuter des commandes externes pour arrêter le processus, golang fournit également une méthode native - appel système .Kill. Cette fonction peut tuer directement le PID du processus spécifié.

Exemple de code :

pid := 123 // 进程的PID
err := syscall.Kill(pid, syscall.SIGKILL) // 执行kill命令
if err != nil {
    fmt.Println("kill process failed: ", err)
}

Le code ci-dessus utilise la fonction syscall.Kill pour arrêter le processus PID spécifié. SIGKILL est la commande kill du système Linux, qui peut tuer directement le processus, ce qui équivaut à mettre fin de force au processus.

Ensuite, nous analysons la méthode d'exécution de syscall.Kill en fonction du code :

1. Il est nécessaire d'exécuter le programme avec les droits d'administrateur, sinon il le fera ne pas être tué car il n'y a pas d'autorisation Spécifiez le processus.
2. Créez la variable pid pour stocker le PID du processus.
3. Appelez syscall.Kill(pid, SIGKILL) pour tuer le processus.
4. Gérez l'erreur err renvoyée par syscall.Kill. Si err n'est pas nul, cela signifie que l'exécution de la commande a échoué.

Méthode 3 : Utiliser des bibliothèques tierces

En plus des deux méthodes ci-dessus, nous pouvons également utiliser des bibliothèques tierces pour réaliser la fonction de fermeture d'autres programmes. La bibliothèque la plus couramment utilisée est la bibliothèque github.com/mitchellh/go-ps, qui peut renvoyer des informations sur tous les processus actuellement en cours d'exécution dans le système.

Nous pouvons trouver le processus avec le nom spécifié et le tuer en fonction des informations sur le processus.

Exemple de code :

processes, err := ps.Processes()
if err != nil {
    fmt.Println("get processes failed: ", err)
    return
}
for _, p := range processes {
    if strings.Contains(p.Executable(), "notepad") {
        err := syscall.Kill(p.Pid(), syscall.SIGTERM)
        if err != nil {
            fmt.Println("kill process failed: ", err)
        }
    }
}

Le code ci-dessus obtient toutes les informations de processus dans le système via la bibliothèque tierce github.com/mitchellh/go-ps, puis les parcourt processus, recherchez le processus avec le bloc-notes dans son nom et tuez-le.

Ensuite, nous analysons l'utilisation de la bibliothèque go-ps en fonction du code :

1. Présentez la bibliothèque github.com/mitchellh/go-ps.
2. Appelez la méthode ps.Processes() pour obtenir toutes les informations sur les processus dans le système.
3. Parcourez les informations sur le processus et recherchez le processus portant le nom spécifié.
4. Appelez la méthode syscall.Kill(p.Pid(), SIGTERM) pour tuer le processus.
5. Gérer l'erreur err renvoyée par syscall.Kill Si err n'est pas nul, cela signifie que l'exécution de la commande a échoué.

Parmi les trois méthodes ci-dessus, exec.Command et syscall.Kill sont des méthodes golang natives et sont relativement simples à utiliser. La méthode d'utilisation de bibliothèques tierces nécessite l'introduction de bibliothèques externes, mais vous pouvez obtenir des informations plus riches, telles que l'heure de démarrage du processus, etc.

Résumé

Grâce aux trois méthodes ci-dessus, nous pouvons réaliser la fonction du programme Golang fermant d'autres programmes. Lorsque nous devons garantir le bon fonctionnement du programme, nous pouvons ainsi supprimer les processus inutiles dans le système pour garantir la stabilité du programme. Il convient de noter que lorsque vous utilisez ces méthodes, portez une attention particulière au PID et au nom du processus pour éviter de supprimer accidentellement d'autres processus.

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!