Bagaimana untuk menutup proses kanak-kanak dengan anggun di Golang

Golang ialah bahasa pengaturcaraan berkuasa yang menyokong pengaturcaraan berbilang proses. Memulakan proses kanak-kanak dalam Go adalah mudah, tetapi menutupnya memerlukan beberapa helah. Artikel ini akan memperkenalkan cara menutup proses kanak-kanak di Golang dengan anggun.

1. Memulakan subproses
Memulakan subproses dalam Golang adalah sangat mudah. ​​Anda boleh menggunakan fungsi Perintah dalam pakej exec. Berikut ialah contoh memulakan arahan:

cmd := exec.Command("ls", "-l")
err := cmd.Start()
if err != nil {
    log.Fatal(err)
}

Kod ini akan memulakan proses anak perintah "ls -l".

2. Tutup proses anak
Apabila proses anak selesai, kita perlu memanggil fungsi Tunggu untuk menunggu proses anak ditutup. Walau bagaimanapun, jika kita memulakan proses anak dalam gelung tak terhingga, maka beberapa helah yang lebih maju diperlukan untuk menutup proses anak.

Pertama, kita perlu menyimpan PID proses anak dalam pembolehubah. Ini boleh dicapai menggunakan fungsi Getpid dalam pakej syscall. Kemudian, apabila kita perlu menutup proses anak, kita boleh menggunakan fungsi Kill dalam pakej syscall untuk menghantar isyarat sistem pengendalian.

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

Program ini akan memulakan proses kanak-kanak dengan arahan "sleep 10", kemudian tunggu 5 saat dan kemudian hantar isyarat SIGTERM untuk mematikan proses kanak-kanak. Kami menggunakan fungsi masa.AfterFunc untuk melaksanakan operasi selepas 5 saat dan fungsi syscall.Kill untuk menghantar isyarat. Selepas menyelesaikan operasi, kami menggunakan fungsi cmd.Wait untuk menunggu proses anak ditutup.

3. Tutup proses anak dengan anggun
Dalam contoh di atas, kami menghantar isyarat SIGTERM untuk menutup proses anak. Isyarat ini akan ditangkap oleh proses, dan proses boleh melakukan beberapa kerja pembersihan selepas menangkap isyarat, dan kemudian keluar seperti biasa.

Jika proses anak tidak menangkap isyarat, kita perlu menggunakan isyarat SIGKILL untuk memaksa proses anak ditutup. Isyarat ini akan mematikan proses secara langsung tanpa memberi sebarang peluang kepada proses untuk membersihkannya. Menutup secara paksa proses kanak-kanak boleh menyebabkan proses meninggalkan fail sementara dan menduduki sumber sistem.

Mematikan proses kanak-kanak boleh dicapai dengan menghantar isyarat keluar kepada proses kanak-kanak. Isyarat ini boleh ditangkap oleh proses kanak-kanak dan proses itu ditutup dengan selamat selepas ditangkap.

Untuk menggunakan isyarat keluar, kita perlu menyokong isyarat dalam kod proses anak. Di Golang, ini boleh dicapai melalui fungsi Isyarat dalam pakej os. Berikut ialah contoh subproses yang menyokong isyarat keluar:

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

Atur cara ini memulakan gelung tak terhingga yang mencetak "Bekerja..." setiap saat. Dalam kod proses kanak-kanak, kami mencipta saluran isyarat sigchan dan menggunakan isyarat.Fungsi pemberitahuan untuk menghantar isyarat SIGTERM ke saluran.

Kami kemudian menunggu dalam gelung tak terhingga untuk menerima isyarat. Setelah isyarat ini diterima, kami mencetak mesej keluar dan menamatkan proses menggunakan fungsi os.Exit.

Sekarang kita mempunyai subproses yang menyokong isyarat keluar, kita boleh menggunakan kod berikut untuk menutupnya:

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

Program ini akan memulakan subproses perintah test1, menunggu Hantar a Isyarat SIGTERM untuk menutup proses kanak-kanak selepas 5 saat. Dalam keadaan biasa, proses kanak-kanak harus mencetak mesej keluar dan keluar seperti biasa.

Ringkasnya, menutup proses kanak-kanak tidak begitu sukar di Golang. Kita boleh menggunakan fungsi Kill dalam pakej syscall untuk menghantar isyarat, atau menyokong isyarat keluar dalam kod proses anak untuk menutup proses anak dengan anggun.

Atas ialah kandungan terperinci Bagaimana untuk menutup proses kanak-kanak dengan anggun di Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!