Petua Lanjutan: WaitGroup dan Penjadualan Coroutine di Golang

Kemahiran lanjutan: WaitGroup dan penjadualan coroutine di Golang, perlukan contoh kod khusus

Pengenalan#🎟#🎜🎜🎜🎜##🎜 , goroutine ialah pelaksanaan utas ringan yang membolehkan pembangun melaksanakan pelbagai tugas secara serentak dengan mudah. Walau bagaimanapun, apabila berurusan dengan tugasan serentak, kita kadangkala perlu menunggu semua tugasan selesai sebelum meneruskan ke langkah seterusnya. Ini memerlukan penggunaan WaitGroup dan penjadualan coroutine. Artikel ini akan memperkenalkan cara menggunakan WaitGroup dan penjadualan coroutine untuk mengendalikan tugas serentak, dengan contoh kod khusus.

1. Konsep WaitGroup

WaitGroup ialah struktur di Golang yang digunakan untuk menunggu siapnya kumpulan coroutine. Ia menyediakan tiga kaedah: Tambah(), Selesai() dan Tunggu(). Apabila kami menambah coroutine, gunakan kaedah Add() untuk menambah kiraannya dengan satu, dan apabila coroutine selesai, gunakan kaedah Done() untuk mengurangkan kiraan dengan satu. Dalam coroutine utama, anda boleh menggunakan kaedah Wait() untuk menunggu semua coroutine selesai.

Berikut ialah contoh mudah yang menunjukkan cara menggunakan WaitGroup:

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var wg sync.WaitGroup
    for i := 1; i <= 5; i++ {
        wg.Add(1) // 增加一个协程的计数
        go func(index int) {
            defer wg.Done() // 在协程结束时减少计数
            time.Sleep(time.Second * time.Duration(index))
            fmt.Printf("协程 %d 完成
", index)
        }(i)
    }
    wg.Wait() // 等待所有协程完成
    fmt.Println("所有协程已经完成")
}

Dalam contoh di atas, kami menggunakan gelung untuk mencipta 5 coroutine. Dalam setiap coroutine, kami menggunakan time.Sleep() untuk mensimulasikan operasi yang memakan masa. Di sini, kami menggunakan indeks untuk mengenal pasti setiap coroutine supaya susunan pelaksanaan coroutine dapat dilihat dalam output. Dengan memanggil wg.Add(1), kami memberitahu WaitGroup untuk menunggu coroutine. Kemudian, pada penghujung setiap coroutine, kami menggunakan wg.Done() untuk menunjukkan bahawa coroutine telah selesai. Akhir sekali, kami menggunakan wg.Wait() untuk menunggu semua coroutine selesai.

2. Penjadualan Coroutine

Dalam contoh di atas, kita melihat bahawa perintah pelaksanaan coroutine tidak seperti yang kita harapkan. Ini kerana penjadual coroutine Golang adalah bukan deterministik dan susunan pelaksanaan antara berbilang coroutine tidak dapat diramalkan. Jika kita mahu coroutine dilaksanakan dalam susunan tertentu, kita perlu menggunakan kaedah lain untuk mengawal penjadualan coroutine.

Di Golang, kami boleh menggunakan saluran untuk mencapai penyegerakan dan komunikasi antara coroutine. Apabila coroutine perlu menunggu coroutine lain selesai sebelum meneruskan, coroutine boleh disekat pada saluran sehingga coroutine yang lain menghantar isyarat selesai. Berikut ialah contoh yang menunjukkan cara menggunakan saluran untuk mengawal penjadualan coroutine:

package main

import (
    "fmt"
    "time"
)

func job(index int, done chan bool) {
    time.Sleep(time.Second * time.Duration(index))
    fmt.Printf("协程 %d 完成
", index)
    done <- true // 发送完成信号到通道
}

func main() {
    done := make(chan bool) // 用于接收完成信号的通道
    for i := 1; i <= 5; i++ {
        go job(i, done)
        <-done // 阻塞等待协程完成
    }
    fmt.Println("所有协程已经完成")
    close(done) // 关闭通道
}

Dalam contoh ini, kami mentakrifkan fungsi yang dipanggil kerja yang menerima parameter indeks dan saluran selesai. Dalam fungsi ini, kami menggunakan time.Sleep() untuk mensimulasikan operasi yang memakan masa. Pada penghujungnya, kami menghantar isyarat siap ke saluran selesai untuk menunjukkan bahawa coroutine telah selesai.

Dalam fungsi utama, kami menggunakan gelung for untuk mencipta 5 coroutine, dan untuk setiap coroutine, kami memanggil fungsi kerja dan lulus dalam saluran yang telah selesai. Kemudian, gunakan

Dengan menggunakan saluran untuk penjadualan coroutine, kami boleh memastikan bahawa coroutine dilaksanakan dalam susunan tertentu. Dalam contoh di atas, susunan pelaksanaan coroutine adalah konsisten dengan susunan indeksnya.

Kesimpulan

Artikel ini memperkenalkan cara menggunakan WaitGroup dan penjadualan coroutine untuk mengendalikan tugasan serentak. Dengan menggunakan WaitGroup, kita boleh menunggu sekumpulan coroutine selesai. Menggunakan saluran untuk penjadualan coroutine boleh mengawal susunan pelaksanaan coroutine. Teknik ini sangat berguna apabila berurusan dengan pengaturcaraan serentak dan boleh meningkatkan prestasi dan kecekapan program anda.

Melalui contoh kod dan penjelasan, saya harap pembaca dapat memahami dan menggunakan teknik lanjutan ini untuk menggunakan ciri-ciri serentak Golang dengan lebih baik.

Atas ialah kandungan terperinci Petua Lanjutan: WaitGroup dan Penjadualan Coroutine di Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!