Kawalan serentak dalam Golang dan Go WaitGroup

Kawalan Concurrency dan Go WaitGroup di Golang

Di Golang, kita boleh menggunakan goroutine untuk melaksanakan tugas pelaksanaan serentak. Walau bagaimanapun, dalam beberapa kes, kita perlu mengawal bilangan pelaksanaan serentak untuk mengelakkan penggunaan sumber yang berlebihan atau isu perbalahan serentak. Golang menyediakan beberapa kaedah untuk mencapai kawalan serentak, yang paling biasa digunakan ialah menggunakan Go WaitGroup.

Go WaitGroup ialah semafor pengiraan yang digunakan untuk menunggu sekumpulan goroutine menyelesaikan pelaksanaan. Apabila kita memulakan kumpulan gorouti, kita boleh menggunakan WaitGroup untuk menjejak status gorouti ini dan melakukan langkah seterusnya selepas semua gorouti selesai.

Di bawah ini kami menggunakan contoh kod khusus untuk menunjukkan kawalan serentak di Golang dan penggunaan Go WaitGroup.

package main

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

func main() {
    numWorkers := 5
    var wg sync.WaitGroup

    for i := 0; i < numWorkers; i++ {
        wg.Add(1) // 每启动一个goroutine，等待组加1
        go worker(i, &wg)
    }

    wg.Wait() // 等待所有goroutine完成

    fmt.Println("All workers have finished")
}

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done() // goroutine执行完毕，等待组减1
    
    fmt.Printf("Worker %d started
", id)
    time.Sleep(time.Second) // 模拟耗时操作
    fmt.Printf("Worker %d finished
", id)
}

Dalam contoh ini, kami mempunyai 5 goroutine, dan tugas setiap pelaksanaan adalah untuk memanggil fungsi pekerja. Mula-mula, kami mentakrifkan pembolehubah WaitGroup wg dan memulakan 5 goroutine dalam fungsi utama. Setiap goroutine memanggil fungsi pekerja dan mengendalikan WaitGroup dengan menghantar penunjuk ke wg.

Dalam fungsi pekerja, kami menggunakan defer wg.Done() untuk mengurangkan kiraan kumpulan menunggu selepas goroutine selesai melaksanakan. Ini bermakna setiap goroutine akan memanggil fungsi Done() untuk memberitahu WaitGroup apabila ia selesai. Kemudian, kami menambah beberapa simulasi operasi memakan masa kepada setiap fungsi pekerja untuk melihat kesan pelaksanaan serentak.

Dalam fungsi utama, kami memanggil wg.Wait() untuk menunggu semua goroutine selesai. Ini akan menyebabkan fungsi utama disekat selepas semua goroutine selesai dilaksanakan, sehingga kiraan WaitGroup mencapai sifar.

Jalankan kod di atas, anda akan melihat output yang serupa dengan yang berikut:

Worker 0 started
Worker 1 started
Worker 2 started
Worker 3 started
Worker 4 started
Worker 3 finished
Worker 2 finished
Worker 0 finished
Worker 1 finished
Worker 4 finished
All workers have finished

Seperti yang dapat dilihat dari output, semua goroutine bermula dan berjalan secara serentak, dan memberitahu fungsi utama selepas selesai.

Dengan menggunakan Go WaitGroup, kami boleh mengawal bilangan pelaksanaan serentak dengan mudah dan melakukan operasi seterusnya selepas semua goroutine selesai. Ini sangat membantu untuk mengendalikan tugas serentak berskala besar atau mengehadkan penggunaan sumber.

Ringkasnya, kawalan konkurensi dan Go WaitGroup di Golang ialah alat penting untuk melaksanakan pengaturcaraan serentak. Kami boleh menggunakan WaitGroup untuk menjejak dan mengawal pelaksanaan sekumpulan goroutin untuk memastikan ketepatan dan kestabilan operasi serentak. Dengan cara ini, kami boleh menggunakan pemproses dan sumber berbilang teras dengan lebih baik serta meningkatkan kecekapan pelaksanaan program.

Atas ialah kandungan terperinci Kawalan serentak dalam Golang dan Go WaitGroup. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!