Bagaimanakah saluran dan pekerja berasingan boleh meningkatkan keselarian dalam Go berbanding menggunakan goroutin sahaja?

Pemprosesan Selari dalam Go

Pengaturcaraan selari melibatkan pelaksanaan berbilang tugas serentak, membolehkan prestasi yang lebih baik dalam aplikasi yang boleh dibahagikan kepada unit bebas. Satu cara untuk mencapai keselarian dalam Go ialah melalui goroutin, utas ringan yang dilaksanakan serentak dengan program utama.

Pertimbangkan kod berikut:

<code class="go">package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    for i := 0; i < 3; i++ {
        go f(i)
    }

    // prevent main from exiting immediately
    var input string
    fmt.Scanln(&input)
}

func f(n int) {
    for i := 0; i < 10; i++ {
        dowork(n, i)
        amt := time.Duration(rand.Intn(250))
        time.Sleep(time.Millisecond * amt)
    }
}

func dowork(goroutine, loopindex int) {
    // simulate work
    time.Sleep(time.Second * time.Duration(5))
    fmt.Printf("gr[%d]: i=%d\n", goroutine, loopindex)
}</code>

Kod ini menggunakan gorouti untuk melaksanakan f serentak berfungsi tiga kali. Fungsi dowork mensimulasikan beberapa kerja dengan tidur selama 5 saat.

Bolehkah anda menganggap bahawa fungsi dowork akan dilaksanakan secara selari?

Ya, anda boleh membuat andaian ini. Secara lalai, Go menetapkan GOMAXPROCS kepada bilangan teras yang tersedia, yang membolehkan berbilang gorout dilaksanakan serentak.

Adakah ini cara yang betul untuk mencapai keselarian?

Ia adalah cara yang sah untuk mencapai keselarian, tetapi ia mungkin bukan pendekatan yang paling berkesan. Menggunakan goroutine tanpa mekanisme penyegerakan boleh membawa kepada perlumbaan data dan hasil yang salah.

Menggunakan Saluran dan Asingkan Pekerja kerja

Cara yang lebih berstruktur dan berskala untuk mencapai keselarian adalah dengan menggunakan saluran dan pekerja dowork yang berasingan. Pendekatan ini memastikan setiap goroutine mempunyai salinan data yang dikongsi sendiri dan berkomunikasi melalui penghantaran mesej.

Berikut ialah contoh menggunakan saluran:

<code class="go">var results = make(chan int) // channel to collect results

func main() {
    // spawn a worker for each goroutine
    for i := 0; i < 3; i++ {
        go worker(i)
    }

    // collect results from the worker goroutines
    for i := 0; i < 10; i++ {
        result := <-results
        fmt.Println("Received result:", result)
    }
}

func worker(n int) {
    for i := 0; i < 10; i++ {
        // perform work and send result through the channel
        res := dowork(n, i)
        results <- res
    }
}</code>

Kesimpulan

Paralelisme dalam Go boleh dicapai dengan goroutin. Menggunakan saluran dan pekerja berasingan ialah pendekatan yang lebih berstruktur dan berskala yang memastikan integriti data dan meningkatkan prestasi.

Atas ialah kandungan terperinci Bagaimanakah saluran dan pekerja berasingan boleh meningkatkan keselarian dalam Go berbanding menggunakan goroutin sahaja?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!