Bagaimana untuk menggunakan pelbagai proses dalam Go?

Dengan peningkatan prestasi komputer dan populariti pemproses berbilang teras, pengaturcaraan berbilang proses secara beransur-ansur menjadi bahagian yang amat diperlukan dalam bidang pengaturcaraan moden. Dalam bahasa Go, pengaturcaraan berbilang proses juga sangat mudah untuk dilaksanakan. Artikel ini akan memperkenalkan cara menggunakan pelbagai proses dalam Go.

1. Goroutines
Dalam bahasa Go, pengaturcaraan serentak boleh dicapai melalui Goroutines. "Goroutine" boleh dianggap sebagai "benang ringan" dalam bahasa Go. Goroutines dijadualkan mengikut masa jalan Go, bukan oleh sistem pengendalian. Oleh itu, dalam bahasa Go, menggunakan Goroutines untuk membuka berbilang urutan tidak membawa terlalu banyak overhed. Seperti yang ditunjukkan di bawah, ialah contoh mudah menggunakan Goroutines:

package main

import (
    "fmt"
    "time"
)

func main() {
    go task1()
    go task2()
    time.Sleep(3*time.Second)
}

func task1() {
    for i := 1; i <= 5; i++ {
        fmt.Println("Task 1: ", i)
        time.Sleep(time.Second)
    }
}

func task2() {
    for i := 1; i <= 5; i++ {
        fmt.Println("Task 2: ", i)
        time.Sleep(time.Second)
    }
}

Dalam contoh di atas, atur cara menggunakan dua Goroutines untuk memulakan dua tugasan, tugas1 dan tugas2. Setiap tugasan akan mengeluarkan nombornya sendiri dan kemudian berhenti seketika. Program akhirnya menggunakan masa.Sleep(3*time.Second) dan menunggu selama tiga saat sebelum program tamat untuk memastikan kedua-dua tugasan selesai.

2. Gunakan pakej os untuk melaksanakan pelbagai proses
Dalam bahasa Go, anda boleh menggunakan fungsi StartProcess dalam pakej os untuk memulakan proses baharu. Fungsi StartProcess menerima laluan fail boleh laku sebagai parameter, dan fungsi ini akan menjalankan fail boleh laku sebagai proses baharu. Pada masa yang sama, melalui tetapan parameter fungsi StartProcess, stdin, stdout atau stderr program semasa boleh dialihkan ke program yang dimulakan. Dalam contoh berikut, mulakan arahan luaran dan biarkan program menunggu pelaksanaan arahan selesai:

package main

import (
    "fmt"
    "os"
    "os/exec"
)

func main() {
    binary, lookErr := exec.LookPath("ls")
    if lookErr != nil {
        panic(lookErr)
    }

    args := []string{"ls", "-a", "-l", "-h"}

    env := os.Environ()

    execErr := syscall.Exec(binary, args, env)
    if execErr != nil {
        panic(execErr)
    }
}

Dalam contoh di atas, program menggunakan fungsi exec.LookPath untuk mencari arahan ls yang boleh dilaksanakan dalam sistem dan bersedia untuk memulakan proses baharu. Pada masa yang sama, dengan mentakrifkan pembolehubah args, parameter yang perlu dihantar kepada arahan selepas memulakan proses ditetapkan. Akhir sekali, gunakan fungsi syscall.Exec untuk memulakan proses baharu.

3. Gunakan komunikasi saluran
Dalam bahasa Go, saluran boleh digunakan untuk pemindahan data dan penyelarasan antara proses yang berbeza. Menggunakan saluran boleh mengelakkan keadaan perlumbaan yang disebabkan oleh proses mengakses sumber yang sama. Dalam contoh berikut, penggunaan komunikasi saluran antara tiga proses berbeza ditunjukkan:

package main

import (
    "fmt"
    "os"
    "strconv"
)

func main() {
    c := make(chan int)
    go pinger(c)
    go ponger(c)
    go printer(c)

    var input string
    fmt.Scanln(&input)
}

func pinger(c chan<- int) { // send only channel
    for i := 0; ; i++ {
        c <- i
    }
}

func ponger(c chan<- int) { // send only channel
    for i := 0; ; i++ {
        c <- i*2
    }
}

func printer(c <-chan int) { // receive only channel
    for {
        fmt.Println("Received value: ", <-c)
    }
}

Dalam contoh di atas, tiga Goroutines didayakan dalam program. Fungsi pinger dan ponger menggunakan jenis saluran "hantar sahaja" untuk menghantar data ke fungsi pencetak. Fungsi pencetak menggunakan jenis saluran "terima sahaja", dan menggunakan gelung tak terhingga untuk terus membaca data daripada saluran dan mencetak output.

Ringkasan
Bahasa Go menyediakan pelbagai cara untuk menggunakan berbilang proses, termasuk menggunakan Goroutines, os.StartProcess dan komunikasi saluran, dsb. Menggunakan kaedah ini boleh menggunakan kuasa pengkomputeran pemproses berbilang teras dengan lebih baik dan meningkatkan prestasi program dan keselarasan. Pada masa yang sama, setiap kaedah mempunyai kelebihan dan kelemahan tersendiri Dalam proses pengaturcaraan sebenar, kaedah yang berbeza perlu dipilih mengikut senario tertentu.

Atas ialah kandungan terperinci Bagaimana untuk menggunakan pelbagai proses dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!