Bagaimanakah Saya Boleh Mengawal Perintah Pelaksanaan Goroutines dalam Go?

Memahami Perintah Pelaksanaan Goroutine

Dalam program berasaskan goroutine, susunan pelaksanaan goroutine boleh menjadi tidak dapat diramalkan. Ini kerana goroutin dilaksanakan serentak dan tidak ada jaminan bila atau mengikut urutan mereka akan menyelesaikan tugasan mereka.

Pertimbangkan coretan kod berikut:

func sum(a []int, c chan int) {
    fmt.Println("summing: ", a)
    total := 0
    for _, v := range a {
        total += v
    }
    c <- total  // send total to c
}

func main() {
    c := make(chan int)

    go sum([]int{1,2,3}, c)
    go sum([]int{4,5,6}, c)

    x := <-c
    fmt.Println(x)
    x = <-c
    fmt.Println(x)
}

Dalam contoh ini, dua goroutin dilancarkan untuk mengira hasil tambah dua keping integer. Walau bagaimanapun, tertib di mana ia dilaksanakan dan keputusannya dicetak tidak bersifat deterministik. Anda boleh melihat output sebagai:

summing:  [4 5 6]
15
summing:  [1 2 3]
6

atau

summing:  [1 2 3]
6
summing:  [4 5 6]
15

Untuk menyegerakkan susunan pelaksanaan goroutine, pelbagai pendekatan boleh digunakan:

Menggunakan Menyekat Saluran:

Dengan menggunakan sifat menyekat saluran, anda boleh memaksa goroutine utama untuk menunggu siap setiap goroutine sebelum beralih ke yang seterusnya. Contohnya:

func main() {

    c := make(chan int)

    go sum([]int{1, 2, 3}, c)

    // Blocks until a value is received
    x := <-c
    fmt.Println(x)

    // Execute the next goroutine
    go sum([]int{4, 5, 6}, c)

    x = <-c
    fmt.Println(x)
}

Menggunakan Kumpulan Tunggu:

Satu lagi teknik penyegerakan biasa melibatkan penggunaan kumpulan tunggu. Kumpulan menunggu menjejaki bilangan gorout yang masih berjalan dan menunggu kesemuanya selesai sebelum meneruskan lebih jauh. Begini cara anda boleh menggunakan kumpulan tunggu dalam contoh di atas:

func sum(a []int, c chan int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Println("summing: ", a)
    total := 0
    for _, v := range a {
        total += v
    }
    c <- total // send total to c
}

func main() {

    c := make(chan int)
    wg := new(sync.WaitGroup)

    // Increment the wait group
    wg.Add(1)
    // Launch the first goroutine
    go sum([]int{1, 2, 3}, c, wg)

    // Wait for the first goroutine to complete
    wg.Wait()

    // Increment the wait group again
    wg.Add(1)
    // Launch the second goroutine
    go sum([]int{4, 5, 6}, c, wg)

    // Wait for the second goroutine to complete
    wg.Wait()

    // Close the channel to indicate that no more values will be sent
    close(c)

    // Range over the channel to receive the results
    for theSum := range c {
        x := theSum
        fmt.Println(x)
    }

}

Dengan memasukkan teknik penyegerakan ke dalam kod anda, anda mendapat kawalan yang lebih besar ke atas susunan goroutine melaksanakan, memastikan mereka menyelesaikan tugas mereka dalam urutan yang dikehendaki.

Atas ialah kandungan terperinci Bagaimanakah Saya Boleh Mengawal Perintah Pelaksanaan Goroutines dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!