Bagaimana untuk Melaksanakan Perintah dalam Go dan Tanggalkannya daripada Proses Induk?

Jalankan Perintah dalam Go dan Tanggalkan Ia daripada Proses

Dalam Go, anda boleh melaksanakan arahan secara berasingan, membenarkan ia dijalankan secara bebas daripada program anda. Begini cara anda boleh mencapai ini:

Kod:

<code class="go">package main

import (
    "fmt"
    "log"
    "os"
    "os/exec"
    "strconv"
    "syscall"
)

func main() {
    // Define the command and its arguments
    cmd := exec.Command("sleep", "120")

    // Set up the pipes for stdout and stderr
    stdoutPipe, err := cmd.StdoutPipe()
    if err != nil {
        log.Fatal(err)
    }
    stderrPipe, err := cmd.StderrPipe()
    if err != nil {
        log.Fatal(err)
    }

    // Start the command
    if err := cmd.Start(); err != nil {
        log.Fatal(err)
    }

    // Get the process ID (PID) of the child process
    pid := cmd.Process.Pid

    // Print the PID
    fmt.Printf("PID: %d\n", pid)

    // Read from the stdout and stderr pipes and log the output
    go func() {
        for {
            buf := make([]byte, 1024)
            n, err := stdoutPipe.Read(buf)
            if err != nil {
                log.Fatal(err)
            }
            fmt.Printf("stdout: %s", string(buf[:n]))
        }
    }()
    go func() {
        for {
            buf := make([]byte, 1024)
            n, err := stderrPipe.Read(buf)
            if err != nil {
                log.Fatal(err)
            }
            fmt.Printf("stderr: %s", string(buf[:n]))
        }
    }()

    // Wait for the command to finish
    if err := cmd.Wait(); err != nil {
        if exitErr := cmd.ProcessState.Sys().(syscall.WaitStatus).ExitStatus(); exitErr != 0 {
            log.Fatal(fmt.Sprintf("Error #48692663: Command exited with code %d", exitErr))
        } else {
            log.Printf("Command exited with exit code 0")
        }
    }

    // Optionally, keep the child process alive even after the parent process exits
    // This can be achieved by setting `cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}` before starting the command.

    // Example of sending a signal to the detached process
    if err := syscall.Kill(pid, os.Interrupt); err != nil {
        log.Fatalf("Error sending signal to process: %d: %s", pid, err)
    } else {
        fmt.Printf("Received ^C and forwarded to process %d\n", pid)
    }

    // Optionally, use `syscall.Reap()` to clean up any child processes that are terminated but not yet waited for.
}</code>

Kod ini menunjukkan cara untuk melaksanakan arahan dalam cara yang terpisah, membolehkannya terus berjalan secara bebas daripada proses ibu bapa. Ia menyediakan ciri seperti menangkap stdout dan stderr, mendapatkan ID proses dan secara pilihan menghantar isyarat kepada proses anak.

Pertimbangan Utama:

• Perhatikan bahawa menanggalkan proses tidak menghalangnya daripada menjadi yatim apabila keluar daripada induknya, kerana kernel masih memegang rujukan kepadanya.
• Menggunakan SysProcAttr.Setpgid boleh memastikan proses anak itu hidup secara bebas, tetapi ia mungkin memerlukan tambahan pengendalian dalam kes tertentu.
• Pastikan anda menggunakan Wait() untuk memastikan proses mengembalikan kod keluar dan anda boleh mengendalikan sebarang kemungkinan ralat.
• Gunakan syscall.Reap() untuk membersihkan proses zombi untuk mengelakkan kebocoran sumber.

Atas ialah kandungan terperinci Bagaimana untuk Melaksanakan Perintah dalam Go dan Tanggalkannya daripada Proses Induk?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!