Golang ist eine leistungsstarke Programmiersprache, die die Multiprozessprogrammierung unterstützt. Das Starten eines untergeordneten Prozesses in Go ist einfach, aber das Schließen erfordert einige Tricks. In diesem Artikel erfahren Sie, wie Sie untergeordnete Prozesse in Golang ordnungsgemäß beenden.
1. Starten Sie den Unterprozess
Das Starten des Unterprozesses in Golang ist sehr einfach. Sie können die Befehlsfunktion im Exec-Paket verwenden. Hier ist ein Beispiel für das Starten eines Befehls:
cmd := exec.Command("ls", "-l")
err := cmd.Start()
if err != nil {
log.Fatal(err)
}Nach dem Login kopieren
Dieser Code startet einen untergeordneten Prozess des Befehls „ls -l“.
2. Schließen Sie den untergeordneten Prozess.
Wenn der untergeordnete Prozess abgeschlossen ist, müssen wir die Wait-Funktion aufrufen, um darauf zu warten, dass der untergeordnete Prozess geschlossen wird. Wenn wir den untergeordneten Prozess jedoch in einer Endlosschleife starten, sind einige fortgeschrittenere Tricks erforderlich, um den untergeordneten Prozess herunterzufahren.
Zuerst müssen wir die PID des untergeordneten Prozesses in einer Variablen speichern. Dies kann mit der Getpid-Funktion im Syscall-Paket erreicht werden. Wenn wir dann den untergeordneten Prozess herunterfahren müssen, können wir die Kill-Funktion im Syscall-Paket verwenden, um ein Betriebssystemsignal zu senden.
package main
import (
"fmt"
"os"
"os/exec"
"syscall"
"time"
)
func main() {
cmd := exec.Command("sleep", "10")
err := cmd.Start()
if err != nil {
fmt.Println(err)
os.Exit(1)
}
pid := cmd.Process.Pid
fmt.Printf("Child process started: %v\n", pid)
time.AfterFunc(time.Second*5, func() {
err := syscall.Kill(pid, syscall.SIGTERM)
if err != nil {
fmt.Println(err)
} else {
fmt.Printf("Child process %v terminated\n", pid)
}
})
cmd.Wait()
fmt.Println("Parent process exiting.")
}Nach dem Login kopieren
Dieses Programm startet einen untergeordneten Prozess mit dem Befehl „sleep 10“, wartet dann 5 Sekunden und sendet dann das SIGTERM-Signal, um den untergeordneten Prozess zu beenden. Wir verwenden die Funktion time.AfterFunc, um den Vorgang nach 5 Sekunden auszuführen, und die Funktion syscall.Kill, um das Signal zu senden. Nach Abschluss des Vorgangs warten wir mit der Funktion cmd.Wait, bis der untergeordnete Prozess geschlossen wird.
3. Schließen Sie den untergeordneten Prozess ordnungsgemäß.
Im obigen Beispiel haben wir ein SIGTERM-Signal gesendet, um den untergeordneten Prozess zu schließen. Dieses Signal wird vom Prozess abgefangen, und der Prozess kann nach dem Abfangen des Signals einige Aufräumarbeiten durchführen und dann normal beenden.
Wenn der untergeordnete Prozess das Signal nicht empfängt, müssen wir das SIGKILL-Signal verwenden, um den untergeordneten Prozess zwangsweise zu schließen. Dieses Signal bricht den Prozess direkt ab, ohne ihm die Möglichkeit zu geben, ihn zu bereinigen. Das erzwungene Schließen eines untergeordneten Prozesses kann dazu führen, dass der Prozess temporäre Dateien hinterlässt und Systemressourcen belegt.
Das ordnungsgemäße Beenden eines untergeordneten Prozesses kann erreicht werden, indem ein Beendigungssignal an den untergeordneten Prozess gesendet wird. Dieses Signal kann von einem untergeordneten Prozess abgefangen und der Prozess nach dem Abfangen sicher heruntergefahren werden.
Um das Exit-Signal zu verwenden, müssen wir das Signal im Code des untergeordneten Prozesses unterstützen. In Golang kann dies durch die Signalfunktion im Betriebssystempaket erreicht werden. Hier ist ein Beispiel für einen Unterprozess, der Exit-Signale unterstützt:
package main
import (
"fmt"
"os"
"os/signal"
"syscall"
"time"
)
func main() {
fmt.Println("Child process started.")
sigchan := make(chan os.Signal, 1)
signal.Notify(sigchan, syscall.SIGTERM)
go func() {
<-sigchan
fmt.Println("Received SIGTERM signal, exiting...")
os.Exit(0)
}()
// Start doing some meaningful work.
for {
fmt.Println("Working...")
time.Sleep(time.Second)
}
}Nach dem Login kopieren
Dieses Programm startet eine Endlosschleife, die jede Sekunde „Working...“ ausgibt. Im Code des untergeordneten Prozesses erstellen wir einen Signalkanal-Sigchan und verwenden die signal.Notify-Funktion, um das SIGTERM-Signal an den Kanal zu senden.
Wir warten dann in einer Endlosschleife auf den Empfang dieses Signals. Sobald dieses Signal empfangen wird, drucken wir eine Exit-Nachricht und beenden den Vorgang mithilfe der Funktion os.Exit.
Jetzt haben wir bereits einen Unterprozess, der Exit-Signale unterstützt. Wir können ihn mit dem folgenden Code schließen:
package main
import (
"fmt"
"os"
"os/exec"
"syscall"
"time"
)
func main() {
cmd := exec.Command("./child")
err := cmd.Start()
if err != nil {
fmt.Println(err)
os.Exit(1)
}
pid := cmd.Process.Pid
fmt.Printf("Child process started: %v\n", pid)
time.AfterFunc(time.Second*5, func() {
err := syscall.Kill(pid, syscall.SIGTERM)
if err != nil {
fmt.Println(err)
} else {
fmt.Printf("Child process %v terminated\n", pid)
}
})
cmd.Wait()
fmt.Println("Parent process exiting.")
}Nach dem Login kopieren
Dieses Programm startet einen Unterprozess mit dem Befehl test1, wartet 5 Sekunden und sendet dann das SIGTERM Signal zum Schließen des Unterprozesses. Unter normalen Umständen sollte der untergeordnete Prozess eine Exit-Nachricht ausgeben und normal beendet werden.
Zusammenfassend lässt sich sagen, dass das Schließen eines untergeordneten Prozesses in Golang nicht sehr schwierig ist. Wir können die Kill-Funktion im Syscall-Paket verwenden, um Signale zu senden, oder Exit-Signale im Code des untergeordneten Prozesses unterstützen, um den untergeordneten Prozess ordnungsgemäß herunterzufahren.
Das obige ist der detaillierte Inhalt vonSo schließen Sie untergeordnete Prozesse in Golang ordnungsgemäß. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
