Bagaimana untuk menggunakan coroutine dalam Go?

Dengan perkembangan teknologi Internet, terdapat keperluan yang semakin tinggi untuk berbilang tugas yang cekap. Dalam bahasa Go, coroutine ialah ciri yang sangat penting yang boleh menyelesaikan masalah ini dengan baik. Artikel ini akan memperkenalkan cara menggunakan coroutine untuk melaksanakan pengaturcaraan serentak dalam Go.

1. Apakah itu coroutine?

Coroutine ialah utas ringan, juga dikenali sebagai utas mod pengguna. Berbanding dengan pengaturcaraan berbilang benang tradisional, kelebihan coroutine ialah ia lebih ringan, menduduki kurang sumber sistem, menukar konteks dengan lebih pantas dan tidak perlu menangani isu keselamatan benang seperti kunci seperti pengaturcaraan berbilang benang. Dalam bahasa Go, Goroutine digunakan untuk melaksanakan coroutine.

2. Buat dan mulakan coroutine

Dalam bahasa Go, anda boleh menggunakan pernyataan go untuk memulakan coroutine. Pernyataan go diikuti dengan panggilan fungsi, yang memulakan coroutine baharu untuk melaksanakan fungsi tersebut.

Contohnya:

func main() {
    go printHello()  // 启动一个goroutine去执行printHello函数
    fmt.Println("main function")
}

func printHello() {
    fmt.Println("hello goroutine")
}

Dalam kod di atas, kami menggunakan pernyataan go untuk memulakan coroutine baharu untuk melaksanakan fungsi printHello. Fungsi printHello akan dilaksanakan dalam coroutine baharu tanpa menyekat utas utama. Selepas fungsi utama dilaksanakan, program tidak akan tamat serta-merta kerana fungsi printHello masih berjalan.

3. Komunikasi coroutine

Dalam coroutine, memandangkan memori dikongsi antara coroutine yang berbeza, isu komunikasi antara berbilang coroutine akan terlibat. Bahasa Go menyediakan saluran untuk melaksanakan komunikasi antara coroutine Kaedah komunikasi berasaskan saluran adalah kaedah komunikasi yang sangat cekap dan selamat.

1. Definisi dan permulaan saluran

Dalam bahasa Go, anda boleh menggunakan fungsi make untuk mencipta saluran Sintaksnya ialah:

channel_name := make(chan data_type)

Antaranya, data_type ialah. dihantar dalam saluran Jenis data. Sebagai contoh, dalam kod berikut, kami mencipta saluran yang menghantar data jenis int:

ch := make(chan int)

2 Membaca dan menulis saluran

boleh digunakan untuk operasi penghantaran dan penerimaan . Kedua-dua operasi hantar dan terima disekat.

• Kendalian penghantaran: Gunakan operator <- saluran untuk melaksanakan operasi penghantaran, iaitu:

channel_name <- value

di mana nilai ialah nilai yang akan dihantar. Contohnya, dalam kod berikut, kami menghantar nilai 1 ke saluran bernama ch:

ch <- 1  // 向ch中发送数值1

• Operasi penerimaan: Gunakan operator <- saluran untuk melaksanakan operasi penerimaan, iaitu:

value := <- channel_name

Di mana nilai adalah nilai yang diterima. Sebagai contoh, dalam kod berikut, kami menerima nilai daripada saluran bernama ch dan menetapkannya kepada pembolehubah x:

x := <- ch  // 从ch中接收一个数值，并将其赋值给变量x

Perlu diingatkan bahawa jika tiada data dalam saluran untuk diterima, maka Terima operasi secara automatik menyekat sehingga data tersedia untuk diterima. Begitu juga, jika saluran penuh, operasi hantar akan disekat sehingga terdapat ruang yang mencukupi untuk menghantar.

4 Gunakan berbilang coroutine untuk berkomunikasi

Berikut ialah contoh mudah di mana dua coroutine dicipta, satu menghantar data ke saluran dan satu lagi menerima data daripada saluran . Komunikasi data dalam dua coroutine ini diselesaikan melalui saluran:

func main() {
    ch := make(chan int)
    go producer(ch)
    go consumer(ch)
    time.Sleep(1 * time.Second)
}

func producer(ch chan int) {
    for i := 0; i < 5; i++ {
        ch <- i
    }
}

func consumer(ch chan int) {
    for i := range ch {
        fmt.Println("received:", i)
    }
}

Dalam kod di atas, coroutine pengeluar akan menjana nilai dan menghantar data ke saluran, manakala coroutine pengguna akan menerima data daripada saluran dan Printout . Dalam fungsi utama, kami memulakan coroutine pengeluar dan pengguna masing-masing melalui pernyataan go. Disebabkan sifat saluran yang menyekat, coroutine pengeluar dan pengguna boleh berkomunikasi dengan selamat tanpa perlu risau tentang ketidakkonsistenan data.

4. Penyegerakan coroutine

Dalam pengaturcaraan berbilang coroutine, kadangkala anda perlu menunggu coroutine lain selesai sebelum melaksanakan operasi tertentu. Dalam kes ini, anda perlu menggunakan teknologi penyegerakan coroutine.

Bahasa Go menyediakan pakej Penyegerakan, yang mengandungi beberapa alatan asas untuk penyegerakan coroutine:

• WaitGroup: tunggu sekumpulan coroutine selesai sebelum melakukan operasi.
• Mutex: Kunci Mutex untuk menghalang berbilang coroutine daripada beroperasi pada data yang sama pada masa yang sama.
• Keadaan: Pembolehubah keadaan, membenarkan coroutine menunggu keadaan tertentu untuk dipenuhi sebelum melakukan operasi seterusnya.

Di sini kami mengambil WaitGroup sebagai contoh untuk memperkenalkan pelaksanaan penyegerakan coroutine.

1. Definisi dan permulaan WaitGroup

Sebelum menggunakan WaitGroup, anda perlu menggunakan kaedah Tambah untuk menambah bilangan coroutine untuk menunggu dalam WaitGroup. Contohnya:

var wg sync.WaitGroup
wg.Add(2)

Dalam kod di atas, kami menambahkan dua coroutine pada WaitGroup.

2. Panggil kaedah Selesai selepas pelaksanaan coroutine selesai

Selepas pelaksanaan coroutine selesai, anda perlu memanggil kaedah Selesai WaitGroup untuk menunjukkan bahawa pelaksanaan coroutine coroutine telah selesai, contohnya:

go func() {
    defer wg.Done()  // 协程执行完成后调用Done方法
    ...
}()

Dalam kod di atas, kami menambah coroutine pada WaitGroup dan memanggil kaedah Selesai selepas pelaksanaan coroutine selesai.

3. Tunggu semua coroutine dilaksanakan

Selepas menambah semua coroutine yang perlu ditunggu dalam WaitGroup, gunakan kaedah Tunggu untuk menunggu semua coroutine dilaksanakan. Contohnya:

wg.Wait()  // 等待所有协程执行完成

Dalam kod di atas, kami menggunakan kaedah Tunggu untuk menunggu semua pelaksanaan coroutine selesai. Kaedah Tunggu menyekat goroutine utama sehingga semua coroutine dilaksanakan.

5. Ringkasan

Artikel ini memperkenalkan penggunaan coroutine dalam bahasa Go, termasuk mencipta dan memulakan coroutine, komunikasi coroutine, penyegerakan coroutine, dsb. Coroutine ialah ciri yang sangat penting dalam bahasa Go dan memainkan peranan yang sangat penting dalam pengaturcaraan berbilang tugas dan konkurensi tinggi. Menggunakan coroutine boleh menjadikan program berjalan dengan lebih cekap dan stabil, dan juga memudahkan pembangun melaksanakan pengaturcaraan serentak.

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