Apakah WaitGroups dalam bahasa go? Bagaimana untuk menggunakan

Apakah WaitGroups? Artikel berikut akan membawa anda memahami WaitGroups dalam bahasa go dan memperkenalkan cara menggunakan WaitGroups saya harap ia akan membantu anda.

Apakah WaitGroups?

WaitGroups ialah cara yang cekap untuk menyegerakkan goroutin anda. Bayangkan anda mengembara dengan kereta bersama keluarga anda. Ayah anda singgah di pusat beli belah atau restoran makanan segera untuk membeli makanan dan menggunakan bilik mandi. Lebih baik anda menunggu sehingga semua orang pulang sebelum memandu ke Horizon. WaitGroups membantu anda melakukan perkara itu.

WaitGroups ditakrifkan dengan memanggil pakej sync dalam pustaka standard.

var wg sync.WaitGroup

Jadi, apakah itu WaitGroup? WaitGroup ialah struktur yang mengandungi maklumat tertentu tentang berapa banyak goroutineyang perlu ditunggu oleh program. Ia adalah kumpulan yang mengandungi goroutines amaun yang anda perlu tunggu.

WaitGroups mempunyai tiga kaedah paling penting: Add, Done dan Wait.

• Tambah: Tambahkan pada jumlah goroutin yang anda perlu tunggu.
• Selesai: Tolak satu daripada jumlah bilangan goroutin yang anda perlu tunggu.
• Tunggu: Sekat kod daripada diteruskan sehingga tiada lagi goroutine yang perlu ditunggu.

Cara menggunakan WaitGroups

Mari kita lihat sekeping kod:

package main

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

func main() {
    var wg sync.WaitGroup
    wg.Add(1)

    go func() {
        defer wg.Done()

        fmt.Println(time.Now(), "start")
        time.Sleep(time.Second)
        fmt.Println(time.Now(), "done")
    }()

    wg.Wait()
    fmt.Println(time.Now(), "exiting...")
}

2022-08-21 17:01:54.184744229 +0900 KST m=+0.000021800 start
2022-08-21 17:01:55.184932851 +0900 KST m=+1.000210473 done
2022-08-21 17:01:55.18507731 +0900 KST m=+1.000354912 exiting...

• Kami mulakan mula-mula Satu contoh WaitGroup wg.
• Kemudian kita tambah 1 pada wg kerana kita nak tunggu satu goroutine selesai.
• Kemudian kami menjalankan ini goroutine. Di dalam goroutine kami membuat panggilan kelewatan ke wg.Done() untuk memastikan kami mengurangkan bilangan goroutine yang perlu ditunggu. Jika kita tidak melakukan ini, maka kod akan menunggu selama-lamanya untuk goroutine selesai dan akan menyebabkan kebuntuan.
• Selepas panggilan goroutine, kami ingin memastikan untuk menyekat kod sehingga WaitGroup kosong. Kami melakukan ini dengan memanggil wg.Wait().

Mengapa menggunakan WaitGroups dan bukannya saluran?

Sekarang kita tahu cara menggunakan WaitGroups, pemikiran semula jadi membawa kita kepada soalan ini: mengapa menggunakan WaitGroups dan bukannya saluran?

Dalam pengalaman saya, terdapat beberapa sebab.

• WaitGroups cenderung lebih intuitif. Apabila anda membaca sekeping kod, apabila anda melihat WaitGroup, anda serta-merta tahu apa yang dilakukan oleh kod tersebut. Nama kaedah adalah jelas dan sampai ke intinya. Walau bagaimanapun, dengan saluran, kadangkala ia tidak begitu jelas. Menggunakan saluran adalah bijak, tetapi apabila anda membaca sekeping kod yang kompleks, ia boleh menyusahkan untuk difahami.
• Kadangkala, anda tidak perlu menggunakan saluran. Sebagai contoh, mari lihat kod ini:

 var wg sync.WaitGroup

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

          fmt.Println(time.Now(), "start")
          time.Sleep(time.Second)
          fmt.Println(time.Now(), "done")
      }()
  }

  wg.Wait()
  fmt.Println(time.Now(), "exiting...")

Seperti yang anda lihat, ini goroutine tidak berkomunikasi dengan yang lain goroutine. Jika goroutine anda adalah kerja sekali sahaja dan anda tidak perlu mengetahui hasilnya, menggunakan WaitGroup adalah lebih baik. Sekarang lihat kod ini:

  ch := make(chan int)

  for i := 0; i < 5; i++ {
      go func() {
          randomInt := rand.Intn(10)
          ch <- randomInt
      }()
  }

  for i := 0; i < 5; i++ {
      fmt.Println(<-ch)
  }

Di sini, goroutine sedang menghantar data ke channel. Dalam kes ini kita tidak perlu menggunakan WaitGroup kerana ia akan berlebihan. Jika penerimaan telah melakukan penyekatan yang mencukupi, mengapa menunggu goroutine selesai?

WaitGroups digunakan khas untuk mengendalikan menunggu goroutines. Saya fikir tujuan utama saluran adalah untuk menyampaikan data. Anda tidak boleh menggunakan WaitGroup untuk menghantar dan menerima data, tetapi anda boleh menggunakan channel untuk menyegerakkan goroutines anda.

Akhirnya, tiada jawapan yang betul. Saya tahu ini boleh menjengkelkan, tetapi ia bergantung kepada anda dan pasukan yang anda bekerjasama. Apa sahaja kaedah yang terbaik, tiada jawapan yang salah. Saya secara peribadi lebih suka menggunakan WaitGroups untuk penyegerakan, tetapi situasi anda mungkin berbeza. Pilih perkara yang anda rasa paling intuitif.

Satu perkara yang perlu diberi perhatian

Kadangkala, anda mungkin perlu menghantar WaitGroup contoh kepada goroutine. Mungkin terdapat beberapa WaitGroups untuk mengendalikan goroutines yang berbeza, atau ia mungkin pilihan reka bentuk. Walau apa pun sebabnya, pastikan anda menghantar penunjuk ke WaitGroup, seperti ini:

var wg sync.WaitGroup

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

        fmt.Println(time.Now(), "start")
        time.Sleep(time.Second)
        fmt.Println(time.Now(), "done")
    }(&wg)
}

wg.Wait()
fmt.Println(time.Now(), "exiting...")

Sebabnya ialah Go ialah bahasa nilai pas. Ini bermakna setiap kali anda menghantar hujah kepada fungsi, Go menyalin hujah dan meneruskannya dan bukannya objek asal. Apa yang berlaku dalam kes ini ialah keseluruhan objek WaitGroup akan disalin, yang bermaksud goroutine akan mengendalikan WaitGroup yang berbeza sama sekali. wg.Done() tidak ditolak daripada wg asal, tetapi salinannya, yang hanya wujud dalam goroutine.

Ringkasan

Dengan menggunakan WaitGroups, kami boleh menyegerakkan dengan mudah goroutines memastikan kod kami dilaksanakan pada masa yang tepat. Walaupun saluran juga boleh digunakan untuk penyegerakan, WaitGroups secara amnya lebih intuitif dan lebih mudah dibaca. Apabila menggunakan WaitGroup, pastikan anda menghantar penunjuk ke WaitGroup dengan betul untuk mengelakkan masalah penyalinan. Tidak kira kaedah yang anda pilih, pilih kaedah yang paling intuitif dan paling sesuai untuk anda dan pasukan anda.

Pembelajaran yang disyorkan: Tutorial Golang

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