Kemahiran pengaturcaraan serentak: Penggunaan lanjutan Go WaitGroup

Petua Pengaturcaraan Serentak: Penggunaan Lanjutan Go WaitGroup

Dalam pengaturcaraan serentak, menyelaras dan mengurus pelaksanaan pelbagai tugas serentak adalah tugas penting. Bahasa Go menyediakan primitif concurrency yang sangat praktikal - WaitGroup, yang boleh membantu kami melaksanakan kawalan concurrency dengan elegan. Artikel ini akan memperkenalkan penggunaan asas WaitGroup dan menumpukan pada penggunaan lanjutannya, menggunakan contoh kod khusus untuk membantu pembaca memahami dan menerapkannya dengan lebih baik.

WaitGroup ialah primitif serentak terbina dalam bahasa Go, yang boleh membantu kami menunggu selesainya tugasan serentak. Ia menyediakan tiga kaedah: Tambah, Selesai dan Tunggu. Kaedah Tambah digunakan untuk menetapkan bilangan tugas menunggu, kaedah Selesai digunakan untuk mengurangkan bilangan tugas menunggu, dan kaedah Tunggu digunakan untuk menyekat coroutine semasa sehingga semua tugas menunggu selesai.

Berikut ialah contoh mudah yang menunjukkan penggunaan asas WaitGroup:

package main

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

func main() {
    var wg sync.WaitGroup

    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(num int) {
            defer wg.Done()

            time.Sleep(time.Second)
            fmt.Println("Task", num, "done")
        }(i)
    }

    wg.Wait()
    fmt.Println("All tasks done")
}

Dalam kod di atas, kami mencipta objek WaitGroup wg dan mencipta 5 tugasan serentak melalui gelung. Semasa pelaksanaan setiap tugasan, kami menggunakan kaedah Tambah untuk menambah bilangan tugas menunggu, dan pada akhir tugasan, kami menggunakan kaedah Selesai untuk mengurangkan bilangan tugas menunggu. Akhir sekali, kami memanggil kaedah Tunggu untuk menyekat coroutine utama sehingga semua tugas menunggu selesai.

Selain penggunaan asas, WaitGroup juga menyediakan beberapa penggunaan lanjutan, yang boleh mengawal pelaksanaan tugas serentak dengan lebih fleksibel. Di bawah ini kami akan memperkenalkan beberapa penggunaan lanjutan yang biasa digunakan secara terperinci.

1. Laksanakan satu set tugasan dan tetapkan bilangan maksimum mata wang

Jika kita perlu melaksanakan satu set tugas pada masa yang sama, tetapi ingin mengehadkan bilangan maksimum mata wang, kita boleh menggunakan saluran buffer digabungkan dengan WaitGroup untuk mencapai ini. Kod di bawah menunjukkan cara untuk melaksanakan satu set tugasan pada masa yang sama, tetapi hanya membenarkan maksimum 3 tugasan untuk dilaksanakan serentak:

package main

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

func main() {
    var wg sync.WaitGroup
    maxConcurrency := 3
    tasks := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

    sem := make(chan struct{}, maxConcurrency)

    for _, task := range tasks {
        wg.Add(1)
        sem <- struct{}{} // 获取令牌，控制最大并发数

        go func(num int) {
            defer wg.Done()

            time.Sleep(time.Second)
            fmt.Println("Task", num, "done")

            <-sem // 释放令牌，允许新的任务执行
        }(task)
    }

    wg.Wait()
    fmt.Println("All tasks done")
}

Dalam kod di atas, kami mencipta saluran buffer sem dan menetapkan saiznya kepada bilangan maksimum daripada concurrencies. Sebelum setiap tugasan bermula, kami memperoleh token melalui penyata sem <- struct{}{} Apabila tugasan selesai, kami menggunakan penyataan <-sem untuk mengeluarkan token. Dengan mengawal pemerolehan dan pelepasan token, kami boleh mengehadkan bilangan maksimum mata wang.

2. Habis masa mengawal pelaksanaan tugas serentak

Kadang-kadang kami mahu mengawal masa pelaksanaan tugas serentak dan menamatkan pelaksanaan tugas apabila tamat tempoh. Dengan menggunakan saluran penimbal dan pemasa, kami boleh melaksanakan fungsi ini dengan mudah. Kod berikut menunjukkan cara untuk menetapkan tamat masa tugasan serentak kepada 3 saat:

package main

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

func main() {
    var wg sync.WaitGroup
    tasks := []int{1, 2, 3, 4, 5, 6, 7}

    timeout := 3 * time.Second
    done := make(chan struct{})

    for _, task := range tasks {
        wg.Add(1)

        go func(num int) {
            defer wg.Done()

            // 模拟任务执行时间不定
            time.Sleep(time.Duration(num) * time.Second)
            fmt.Println("Task", num, "done")

            // 判断任务是否超时
            select {
            case <-done:
                // 任务在超时前完成，正常退出
                return
            default:
                // 任务超时，向通道发送信号
                close(done)
            }
        }(task)
    }



    wg.Wait()
    fmt.Println("All tasks done")
}

Dalam kod di atas, kami mencipta saluran selesai dan menentukan sama ada saluran ditutup semasa pelaksanaan tugasan untuk menentukan sama ada tugasan itu tamat masa. Apabila tugasan selesai, kami menggunakan pernyataan tutup(selesai) untuk menghantar isyarat kepada saluran selesai untuk menunjukkan bahawa tugasan telah tamat masa. Pilih cawangan yang berbeza melalui penyataan pilih untuk mengendalikan situasi yang berbeza.

Melalui contoh kod di atas, kita dapat melihat bahawa penggunaan lanjutan WaitGroup sangat praktikal dalam pengaturcaraan serentak yang sebenar. Menguasai teknik ini, kita boleh mengawal pelaksanaan tugas serentak dengan lebih baik dan meningkatkan prestasi serta kebolehselenggaraan kod. Saya berharap pembaca dapat memperoleh pemahaman yang mendalam tentang penggunaan WaitGroup melalui pengenalan dan contoh kod artikel ini, dan kemudian menggunakannya pada projek sebenar.

Atas ialah kandungan terperinci Kemahiran pengaturcaraan serentak: Penggunaan lanjutan Go WaitGroup. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!