Kaedah kawalan perintah pelaksanaan Goroutine dan Saluran di Golang

Kaedah kawalan jujukan pelaksanaan Goroutines dan Saluran di Golang

Dalam pengaturcaraan Golang, Goroutine dan Channel adalah dua konsep yang sangat penting. Goroutine ialah benang ringan yang boleh menjalankan pelbagai fungsi secara serentak semasa pelaksanaan program. Saluran ialah mekanisme yang digunakan untuk komunikasi antara Goroutines.

Dalam beberapa kes, kita perlu mengawal perintah pelaksanaan Goroutine dan Channel untuk memastikan program berjalan seperti yang kita jangkakan. Artikel ini akan memperkenalkan beberapa kaedah biasa untuk melaksanakan kawalan jujukan Goroutine dan Saluran.

Kaedah 1: Gunakan WaitGroup

WaitGroup ialah kaunter yang digunakan untuk menunggu penghujung kumpulan Goroutine. Prinsip kerjanya ialah setiap kali Goroutine dimulakan, kaunter ditambah dengan satu selepas setiap Goroutine dilaksanakan, kaunter dikurangkan satu. Apabila kaunter mencapai sifar, utas utama meneruskan pelaksanaan.

Berikut ialah kod sampel menggunakan WaitGroup untuk kawalan jujukan:

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup

    wg.Add(2)

    go func() {
        defer wg.Done()
        fmt.Println("Goroutine 1")
    }()

    go func() {
        defer wg.Done()
        fmt.Println("Goroutine 2")
    }()

    wg.Wait()

    fmt.Println("Main Goroutine")
}

Dalam contoh ini, kami mencipta dua Goroutine, setiap Goroutine mencetak mesej. Dalam setiap Goroutine, kami lulus defer wg.Done() 语句将计数器减一。最后，wg.Wait() untuk menyekat utas utama sehingga semua Goroutine dilaksanakan.

Jalankan kod di atas, outputnya ialah:

Goroutine 1
Goroutine 2
Main Goroutine

Adalah dapat dilihat bahawa perintah pelaksanaan Goroutine 1 dan Goroutine 2 tidak pasti, tetapi ia mesti dilengkapkan sebelum benang utama mencetak "Main Goroutine".

Kaedah 2: Gunakan Saluran tanpa buffer

Saluran tidak buffer boleh digunakan untuk menyekat pelaksanaan Goroutine sehingga Goroutine lain menerima data daripada Saluran. Dengan membina rantaian pergantungan Goroutine, kami boleh melaksanakan berbilang Goroutine secara berurutan.

Berikut ialah kod sampel untuk kawalan berjujukan menggunakan Saluran tidak buffer:

package main

import (
    "fmt"
)

func main() {
    ch1 := make(chan struct{})
    ch2 := make(chan struct{})

    go func() {
        fmt.Println("Goroutine 1")
        ch1 <- struct{}{}
    }()

    go func() {
        <-ch1
        fmt.Println("Goroutine 2")
        ch2 <- struct{}{}
    }()

    <-ch2

    fmt.Println("Main Goroutine")
}

Dalam contoh ini, selepas Goroutine 1 mencetak mesej, ia menghantar struktur kosong ke Saluran ch1. Seterusnya, Goroutine 2 mencetak mesej lain selepas menerima data daripada Saluran ch1, dan menghantar struktur kosong ke Saluran ch2. Akhirnya, utas utama mencetak "Gooutine Utama" selepas menerima data daripada Saluran ch2.

Jalankan kod di atas, outputnya ialah:

Goroutine 1
Goroutine 2
Main Goroutine

Anda boleh melihat bahawa perintah pelaksanaan Goroutine 1 dan Goroutine 2 ditentukan, dan ia mesti dilengkapkan sebelum benang utama mencetak "Gooutine Utama".

Kaedah 3: Gunakan Saluran penimbal

Saluran penimbal membolehkan kami menentukan kapasiti semasa menciptanya, yang boleh menyimpan sejumlah data. Dengan menetapkan saiz penimbal dengan sewajarnya, kita boleh mengawal bilangan pelaksanaan serentak Goroutine dan mencapai kawalan jujukan.

Berikut ialah kod sampel untuk kawalan jujukan menggunakan Saluran penimbal:

package main

import (
    "fmt"
)

func main() {
    ch := make(chan struct{}, 2)

    go func() {
        fmt.Println("Goroutine 1")
        ch <- struct{}{}
    }()

    go func() {
        fmt.Println("Goroutine 2")
        ch <- struct{}{}
    }()

    <-ch
    <-ch

    fmt.Println("Main Goroutine")
}

Dalam contoh ini, kami mencipta Saluran ch dengan penampan kapasiti 2. Dalam setiap Goroutine, kami menghantar struktur kosong ke Saluran ch. Akhir sekali, benang utama mencetak "Gooutine Utama" selepas menerima data dua kali daripada Saluran ch.

Jalankan kod di atas, outputnya ialah:

Goroutine 1
Goroutine 2
Main Goroutine

Anda boleh melihat bahawa perintah pelaksanaan Goroutine 1 dan Goroutine 2 ditentukan, dan ia mesti dilengkapkan sebelum benang utama mencetak "Gooutine Utama".

Melalui kaedah di atas, kita boleh mengawal perintah pelaksanaan Goroutine dan Channel secara fleksibel. Mengikut keperluan sebenar, memilih kaedah yang sesuai boleh meningkatkan keselarasan dan kecekapan program.

Ringkasan:

Artikel ini memperkenalkan tiga kaedah biasa untuk mengawal tertib pelaksanaan Goroutine dan Saluran di Golang: menggunakan WaitGroup, menggunakan Saluran yang tidak ditimbal dan menggunakan Saluran yang ditimbal. Dengan menggunakan kaedah ini secara rasional, kawalan serentak yang fleksibel boleh dicapai dan prestasi serta kecekapan program dapat dipertingkatkan.

Atas ialah kandungan terperinci Kaedah kawalan perintah pelaksanaan Goroutine dan Saluran di Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!