Bagaimana sync.WaitGroup Bekerja? Sebuah Tinjauan Sinkronisasi Goroutine Melalui Kode Sumber

Sinkronisasi goroutine adalah aspek fundamental dari pemrograman konkuren di Go. sync.WaitGroup adalah alat yang ampuh yang disediakan oleh perpustakaan standar Go untuk mengelola dan menunggu koleksi goroutine untuk menyelesaikan eksekusinya. Dalam posting blog ini, kita akan mempelajari mekanisme internal sync.WaitGroup, menjelajahi kode sumbernya, dan memahami bagaimana ia memfasilitasi sinkronisasi goroutine yang efisien. Tujuan kami adalah memberikan pemahaman mendalam tentang cara kerja sync.WaitGroup, memungkinkan Anda untuk menggunakannya secara efektif dalam aplikasi Go Anda.

Daftar Isi

1. Pendahuluan untuk Sinkronisasi Goroutine
   • Mengapa kita membutuhkan sinkronisasi goroutine?
   • Memperkenalkan sync.WaitGroup
2. Dasar-Dasar sync.WaitGroup
   • Struktur Dasar
   • Metode Utama: Add, Done, dan Wait
   • Contoh Sederhana
3. Membedah Kode Sumber sync.WaitGroup
   • Struktur Data Internal
   • Implementasi Add
   • Implementasi Done
   • Implementasi Wait
   • Mengelola Kondisi Race
4. Kasus Penggunaan Tingkat Lanjut dan Pola
   • Menunggu Koleksi Goroutine Dinamis
   • Menggunakan sync.WaitGroup dengan Timeout
   • Penanganan Kesalahan dengan sync.WaitGroup
   • sync.WaitGroup vs. Channels: Kapan Menggunakan Apa?
5. Pertimbangan Kinerja
   • Overhead sync.WaitGroup
   • Praktik Terbaik untuk Penggunaan Efisien
6. Perangkap Umum dan Bagaimana Menghindarinya
   • Memanggil Done Terlalu Banyak Kali
   • Lupa Memanggil Wait
   • Masalah Race Condition dengan Variabel Bersama
7. Contoh Kode Lengkap
   • Contoh Kompleks dengan Penanganan Kesalahan
8. Kesimpulan

1. Pendahuluan untuk Sinkronisasi Goroutine

Mengapa Kita Membutuhkan Sinkronisasi Goroutine?

Go secara alami mendukung konkurensi melalui goroutine, fungsi yang dapat berjalan bersamaan dengan fungsi lain. Goroutine ringan dan murah untuk dibuat, menjadikannya ideal untuk aplikasi paralel. Namun, mengelola dan menyinkronkan goroutine sangat penting untuk mencegah kondisi race, memastikan berbagi data yang aman, dan mengkoordinasikan eksekusi yang tepat. Tanpa mekanisme sinkronisasi yang tepat, goroutine dapat saling mengganggu, yang menyebabkan perilaku yang tidak dapat diprediksi dan bug yang sulit dideteksi.

Pertimbangkan sebuah skenario di mana beberapa goroutine perlu memproses sejumlah tugas, dan program utama harus menunggu semua tugas selesai sebelum melanjutkan. Tanpa sinkronisasi, program utama dapat keluar sebelum goroutine menyelesaikan pekerjaan mereka, yang menyebabkan data yang tidak lengkap atau salah. Di sinilah alat seperti sync.WaitGroup berperan, menyediakan cara yang efisien dan terstruktur untuk menunggu koleksi goroutine menyelesaikan eksekusinya.

Memperkenalkan sync.WaitGroup

sync.WaitGroup adalah mekanisme sinkronisasi yang disediakan oleh paket sync di Go. Ini memungkinkan Anda untuk menunggu koleksi goroutine menyelesaikan eksekusinya. Singkatnya, sync.WaitGroup bekerja dengan menjaga penghitung. Setiap kali goroutine dimulai, penghitung dinaikkan. Ketika goroutine selesai, penghitung diturunkan. Program utama menunggu sampai penghitung menjadi nol, menandakan bahwa semua goroutine telah menyelesaikan eksekusi mereka. Ini adalah cara yang sederhana namun ampuh untuk memastikan bahwa semua pekerjaan konkuren selesai sebelum program berlanjut.

Tiga metode utama digunakan dengan sync.WaitGroup:

• Add(delta int): Menaikkan penghitung dengan delta. Ini biasanya dipanggil sebelum meluncurkan goroutine baru.
• Done(): Menurunkan penghitung dengan satu. Ini harus dipanggil oleh setiap goroutine setelah menyelesaikan tugasnya.
• Wait(): Memblokir sampai penghitung menjadi nol. Ini biasanya dipanggil oleh goroutine utama untuk menunggu semua goroutine lain menyelesaikan eksekusi mereka.

2. Dasar-Dasar sync.WaitGroup

Struktur Dasar

sync.WaitGroup adalah struktur yang mengandung penghitung dan mekanisme untuk memblokir dan membangunkan goroutine. Struktur ini tidak diekspor, dan pengguna berinteraksi dengannya melalui metodenya.

Secara internal, sync.WaitGroup menggunakan mutex untuk melindungi penghitung dan kondisi variabel untuk memberi sinyal penyelesaian.

Metode Utama: Add, Done, dan Wait

Untuk menggunakan sync.WaitGroup secara efektif, penting untuk memahami bagaimana setiap metode beroperasi:

• Add(delta int): Metode ini menambah penghitung internal sebesar delta. Argumen delta biasanya 1 ketika memulai goroutine baru, tetapi bisa lebih besar jika satu goroutine memulai beberapa tugas konkuren. Penting untuk memanggil Add sebelum meluncurkan goroutine untuk menghindari kondisi race.
• Done(): Metode ini harus dipanggil oleh setiap goroutine setelah menyelesaikan pekerjaannya. Ini mengurangi penghitung internal sebesar 1. Secara konvensi, Done() biasanya didefer untuk memastikan itu dipanggil bahkan jika goroutine panik.
• Wait(): Metode ini memblokir goroutine yang memanggil (biasanya program utama) sampai penghitung internal menjadi nol. Ini berarti semua goroutine yang ditambahkan ke WaitGroup telah menyelesaikan eksekusi mereka dan memanggil Done().

Contoh Sederhana

Berikut ini adalah contoh sederhana tentang bagaimana menggunakan sync.WaitGroup untuk menunggu tiga goroutine menyelesaikan eksekusi mereka:

“`go
package main

import (
“fmt”
“sync”
“time”
)

func worker(id int, wg *sync.WaitGroup) {
defer wg.Done() // Pastikan Done dipanggil saat fungsi keluar

fmt.Printf(“Goroutine %d dimulai\n”, id)
time.Sleep(time.Second) // Simulasikan beberapa pekerjaan
fmt.Printf(“Goroutine %d selesai\n”, id)
}

func main() {
var wg sync.WaitGroup

// Tambahkan tiga goroutine ke WaitGroup
wg.Add(3)

// Luncurkan tiga goroutine
for i := 1; i <= 3; i++ { go worker(i, &wg) } // Tunggu semua goroutine menyelesaikan wg.Wait() fmt.Println("Semua goroutine selesai. Program berakhir.") } ```

Dalam contoh ini:

1. Kita membuat sync.WaitGroup bernama wg.
2. Kita memanggil wg.Add(3) untuk mengatur penghitung ke 3, satu untuk setiap goroutine yang akan kita luncurkan.
3. Kita meluncurkan tiga goroutine, setiap goroutine menjalankan fungsi worker.
4. Di dalam fungsi worker, kita menggunakan defer wg.Done() untuk memastikan bahwa wg.Done() dipanggil ketika fungsi keluar, terlepas dari apakah itu diselesaikan secara normal atau panik.
5. Dalam fungsi main, kita memanggil wg.Wait() untuk memblokir sampai penghitung menjadi nol, menandakan bahwa semua tiga goroutine telah menyelesaikan eksekusi mereka.

3. Membedah Kode Sumber sync.WaitGroup

Untuk benar-benar memahami bagaimana sync.WaitGroup bekerja, mari kita telusuri kode sumber Go. Perhatikan bahwa kode sumber dapat sedikit berbeda antar versi Go, tetapi prinsip-prinsip dasarnya tetap sama.

Struktur Data Internal

Struktur sync.WaitGroup didefinisikan sebagai berikut (disederhanakan):

“`go
type WaitGroup struct {
noCopy noCopy

state1 [3]uint32
}
“`

Penjelasan:

• noCopy: Ini adalah bidang kosong yang digunakan oleh linter go vet untuk mendeteksi penyalinan struktur WaitGroup dengan nilai. Menyalin WaitGroup tidak aman dan dapat menyebabkan perilaku yang tidak terduga.
• state1: Ini adalah array dari tiga uint32, menyimpan penghitung, penghitung waiter, dan beberapa flag. Struktur ini digunakan untuk menyimpan status internal WaitGroup secara atomik.

Implementasi Add

Metode Add meningkatkan penghitung internal:

“`go
func (wg *WaitGroup) Add(delta int) {
statep := wg.state()
if race.Enabled {
race.ReleaseMerge(unsafe.Pointer(statep))
}
atomic.AddInt64(statep, int64(delta<<32)) } ```

Penjelasan:

• statep := wg.state(): Mendapatkan pointer ke state dari WaitGroup.
• race.ReleaseMerge(unsafe.Pointer(statep)): Bagian ini terlibat dalam deteksi race condition. Ini memberi tahu detektor race bahwa ada operasi sinkronisasi.
• atomic.AddInt64(statep, int64(delta<<32)): Operasi atomik ini meningkatkan penghitung internal. Penghitung dialihkan ke 32 bit paling signifikan dari int64 untuk memisahkannya dari penghitung waiter.

Implementasi Done

Metode Done mengurangi penghitung internal sebesar satu. Ini hanyalah pintasan untuk Add(-1):

```go
func (wg *WaitGroup) Done() {
wg.Add(-1)
}
```

Ketika penghitung menjadi nol, Done membangunkan semua waiter yang diblokir oleh Wait.

Implementasi Wait

Metode Wait memblokir goroutine yang memanggil sampai penghitung internal menjadi nol:

```go
func (wg *WaitGroup) Wait() {
statep := wg.state()
if race.Enabled {
race.Disable()
}
for {
state := atomic.LoadUint64(statep)
v := int32(state >> 32)
if v == 0 {
// Penghitung adalah nol, jadi kita selesai.
if race.Enabled {
race.Enable()
race.Acquire(unsafe.Pointer(statep))
}
return
}
if atomic.CompareAndSwapUint64(statep, state, state+1) {
runtime.Gosched()
runtime.Semacquire(statep)
if race.Enabled {
race.Enable()
race.Acquire(unsafe.Pointer(statep))
}
return
}
}
}
```

Penjelasan:

• state := atomic.LoadUint64(statep): Memuat status WaitGroup secara atomik.
• v := int32(state >> 32): Mengekstrak nilai penghitung dari status.
• if v == 0: Jika penghitung adalah nol, semua goroutine telah selesai, dan metode Wait kembali.
• if atomic.CompareAndSwapUint64(statep, state, state+1): Jika penghitung bukan nol, ia mencoba untuk meningkatkan penghitung waiter secara atomik. Jika berhasil, itu akan memblokir goroutine menggunakan runtime.Semacquire.
• runtime.Gosched(): Memberikan penjadwal goroutine kesempatan untuk menjalankan goroutine lain.
• runtime.Semacquire(statep): Memblokir goroutine sampai goroutine lain (yang memanggil Done) memanggil runtime.Semrelease pada alamat yang sama (statep).
• Ketika penghitung menjadi nol (melalui serangkaian panggilan ke Done), goroutine yang memanggil Wait dibangunkan dan metode Wait kembali.

Mengelola Kondisi Race

Kode sumber sync.WaitGroup menggunakan operasi atomik (dari paket sync/atomic) untuk mengelola penghitung dan penghitung waiter. Operasi atomik memastikan bahwa operasi dijalankan secara atomik, tanpa gangguan dari goroutine lain. Ini membantu mencegah kondisi race dan memastikan integritas status internal WaitGroup.

Selain itu, kode sumber menggunakan flag race.Enabled untuk mengintegrasikan dengan detektor race Go. Detektor race membantu mendeteksi kondisi race selama pengembangan, membuat lebih mudah untuk menulis kode konkuren yang aman.

4. Kasus Penggunaan Tingkat Lanjut dan Pola

Menunggu Koleksi Goroutine Dinamis

Salah satu kasus penggunaan kuat dari sync.WaitGroup adalah menunggu koleksi goroutine dinamis. Ini berguna ketika jumlah goroutine yang diluncurkan tidak diketahui pada waktu kompilasi dan ditentukan secara dinamis pada waktu proses.

Berikut ini contohnya:

```go
package main

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

func processItem(item int, wg *sync.WaitGroup) {
defer wg.Done()
fmt.Printf("Memproses item: %d\n", item)
time.Sleep(time.Millisecond * 500) // Simulasikan beberapa pemrosesan
fmt.Printf("Item diproses: %d\n", item)
}

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

wg.Add(len(items)) // Tambahkan jumlah total item ke WaitGroup

for _, item := range items {
go processItem(item, &wg)
}

wg.Wait() // Tunggu semua item diproses

fmt.Println("Semua item diproses.")
}
```

Dalam contoh ini, jumlah item yang akan diproses ditentukan secara dinamis. Kita memanggil wg.Add(len(items)) untuk menambahkan jumlah goroutine yang benar ke WaitGroup.

Menggunakan sync.WaitGroup dengan Timeout

Dalam beberapa skenario, Anda mungkin ingin menunggu koleksi goroutine untuk periode waktu tertentu dan keluar jika semua goroutine belum selesai dalam jangka waktu itu. Go tidak menyediakan mekanisme timeout bawaan untuk sync.WaitGroup, tetapi Anda dapat mengimplementasikan timeout menggunakan select dengan channel:

```go
package main

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

func worker(id int, wg *sync.WaitGroup) {
defer wg.Done()
fmt.Printf("Goroutine %d dimulai\n", id)
time.Sleep(time.Second * 2) // Simulasikan beberapa pekerjaan
fmt.Printf("Goroutine %d selesai\n", id)
}

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

for i := 1; i <= 3; i++ { go worker(i, &wg) } done := make(chan bool) go func() { wg.Wait() close(done) }() select { case <-done: fmt.Println("Semua goroutine selesai.") case <-time.After(time.Second * 3): fmt.Println("Timeout: Beberapa goroutine tidak selesai dalam jangka waktu.") } fmt.Println("Program berakhir.") } ```

Dalam contoh ini:

1. Kita membuat channel done.
2. Kita meluncurkan goroutine yang menunggu wg.Wait() dan menutup channel done ketika semua goroutine menyelesaikan eksekusi mereka.
3. Kita menggunakan pernyataan select untuk menunggu baik sinyal dari channel done atau timeout dari time.After.
4. Jika semua goroutine menyelesaikan dalam jangka waktu, kita akan menerima sinyal dari channel done, dan program mencetak "Semua goroutine selesai."
5. Jika timeout terlampaui, kita menerima sinyal dari time.After, dan program mencetak "Timeout: Beberapa goroutine tidak selesai dalam jangka waktu."

Penanganan Kesalahan dengan sync.WaitGroup

Menangani kesalahan dalam goroutine dan mengkoordinasikannya menggunakan sync.WaitGroup memerlukan perhatian khusus. Salah satu pendekatan umum adalah menggunakan channel untuk mengumpulkan kesalahan dari goroutine.

```go
package main

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

func worker(id int, wg *sync.WaitGroup, errChan chan error) {
defer wg.Done()
fmt.Printf("Goroutine %d dimulai\n", id)
time.Sleep(time.Millisecond * 500)
if id == 2 {
errChan <- fmt.Errorf("Kesalahan terjadi di goroutine %d", id) return } fmt.Printf("Goroutine %d selesai\n", id) } func main() { var wg sync.WaitGroup errChan := make(chan error, 3) // Buffered channel untuk mengumpulkan kesalahan wg.Add(3) for i := 1; i <= 3; i++ { go worker(i, &wg, errChan) } wg.Wait() close(errChan) // Tutup channel setelah semua goroutine selesai for err := range errChan { fmt.Println("Kesalahan:", err) } fmt.Println("Program berakhir.") } ```

Dalam contoh ini:

1. Kita membuat channel errChan untuk mengumpulkan kesalahan dari goroutine.
2. Setiap goroutine mengirim kesalahan ke errChan jika terjadi kesalahan.
3. Dalam fungsi main, kita menunggu semua goroutine menyelesaikan dan kemudian iterasi atas channel errChan untuk mencetak kesalahan apa pun yang terjadi.

sync.WaitGroup vs. Channels: Kapan Menggunakan Apa?

Baik sync.WaitGroup maupun channel adalah mekanisme sinkronisasi di Go, tetapi mereka melayani tujuan yang berbeda.

• sync.WaitGroup: Ideal untuk menunggu koleksi goroutine untuk menyelesaikan eksekusi mereka. Ini terutama berguna ketika Anda perlu memastikan bahwa semua pekerjaan konkuren selesai sebelum melanjutkan.
• Channels: Ideal untuk komunikasi dan sinkronisasi antar goroutine. Mereka memungkinkan Anda mengirim data dan sinyal antar goroutine, menjadikannya cocok untuk alur kerja kompleks dan pipeline data.

Sebagai aturan umum, gunakan sync.WaitGroup ketika Anda perlu menunggu koleksi goroutine untuk menyelesaikan, dan gunakan channel ketika Anda perlu mengomunikasikan dan menyinkronkan data antar goroutine.

5. Pertimbangan Kinerja

Overhead sync.WaitGroup

sync.WaitGroup relatif ringan, tetapi memiliki beberapa overhead. Overhead utama berasal dari operasi atomik dan kunci yang digunakan untuk mengelola penghitung internal dan kondisi waiter.

Dalam kebanyakan kasus, overhead sync.WaitGroup dapat diabaikan. Namun, dalam aplikasi berkinerja tinggi di mana sync.WaitGroup digunakan sangat sering, penting untuk mempertimbangkan overhead.

Praktik Terbaik untuk Penggunaan Efisien

Untuk menggunakan sync.WaitGroup secara efisien, pertimbangkan praktik terbaik berikut:

• Hindari menyalin sync.WaitGroup: Menyalin sync.WaitGroup dapat menyebabkan perilaku yang tidak terduga dan harus dihindari. Lewatkan sync.WaitGroup dengan pointer jika perlu.
• Gunakan defer wg.Done(): Menggunakan defer wg.Done() memastikan bahwa Done dipanggil bahkan jika goroutine panik.
• Tambahkan penghitung sebelum meluncurkan goroutine: Tambahkan ke WaitGroup sebelum meluncurkan goroutine untuk menghindari kondisi race.
• Batasi penggunaan sync.WaitGroup: Gunakan sync.WaitGroup hanya ketika diperlukan. Untuk alur kerja komunikasi yang sederhana, channel mungkin menjadi solusi yang lebih efisien.

6. Perangkap Umum dan Bagaimana Menghindarinya

Memanggil Done Terlalu Banyak Kali

Salah satu kesalahan umum adalah memanggil Done lebih banyak kali daripada panggilan ke Add. Ini dapat menyebabkan penghitung internal menjadi negatif, yang menyebabkan panik. Untuk mencegah ini, pastikan bahwa setiap goroutine memanggil Done tepat satu kali.

```go
package main

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

func worker(id int, wg *sync.WaitGroup) {
defer wg.Done()
fmt.Printf("Goroutine %d dimulai\n", id)
time.Sleep(time.Millisecond * 500)
fmt.Printf("Goroutine %d selesai\n", id)
// BUG: Memanggil Done dua kali
wg.Done()
}

func main() {
var wg sync.WaitGroup
wg.Add(1)
go worker(1, &wg)
wg.Wait()
fmt.Println("Program berakhir.")
}
```

Contoh ini akan menyebabkan panik karena Done dipanggil dua kali.

Lupa Memanggil Wait

Lupa memanggil Wait dapat menyebabkan program keluar sebelum goroutine menyelesaikan eksekusi mereka. Ini dapat menyebabkan data yang tidak lengkap atau salah. Untuk mencegah ini, selalu pastikan bahwa Anda memanggil Wait setelah meluncurkan semua goroutine.

```go
package main

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

func worker(id int, wg *sync.WaitGroup) {
defer wg.Done()
fmt.Printf("Goroutine %d dimulai\n", id)
time.Sleep(time.Millisecond * 500)
fmt.Printf("Goroutine %d selesai\n", id)
}

func main() {
var wg sync.WaitGroup
wg.Add(1)
go worker(1, &wg)
// BUG: Lupa memanggil Wait
// wg.Wait()
fmt.Println("Program berakhir.")
}
```

Dalam contoh ini, program akan keluar sebelum goroutine menyelesaikan eksekusinya.

Masalah Race Condition dengan Variabel Bersama

sync.WaitGroup hanya menyinkronkan penyelesaian goroutine. Itu tidak melindungi variabel bersama dari kondisi race. Jika Anda memiliki variabel bersama yang diakses oleh beberapa goroutine, Anda perlu menggunakan mekanisme sinkronisasi lain, seperti mutexes, untuk melindungi variabel-variabel tersebut.

```go
package main

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

var counter int
var mutex sync.Mutex

func incrementCounter(wg *sync.WaitGroup) {
defer wg.Done()
for i := 0; i < 1000; i++ { mutex.Lock() counter++ mutex.Unlock() } } func main() { var wg sync.WaitGroup wg.Add(2) go incrementCounter(&wg) go incrementCounter(&wg) wg.Wait() fmt.Println("Penghitung:", counter) } ```

Dalam contoh ini, kita menggunakan mutex untuk melindungi variabel counter dari kondisi race.

7. Contoh Kode Lengkap

Contoh Kompleks dengan Penanganan Kesalahan

Berikut ini adalah contoh kode yang lebih kompleks yang menggabungkan beberapa konsep yang dibahas dalam posting blog ini, termasuk penanganan kesalahan, timeout, dan koleksi goroutine dinamis:

```go
package main

import (
"fmt"
"math/rand"
"sync"
"time"
)

func processItem(id int, item int, wg *sync.WaitGroup, errChan chan error) {
defer wg.Done()
fmt.Printf("Goroutine %d: Memproses item %d\n", id, item)
sleepTime := time.Millisecond * time.Duration(rand.Intn(1000))
time.Sleep(sleepTime)

if rand.Intn(10) < 2 { // Simulasikan kesalahan 20% err := fmt.Errorf("Goroutine %d: Gagal memproses item %d", id, item) errChan <- err return } fmt.Printf("Goroutine %d: Item diproses %d\n", id, item) } func main() { rand.Seed(time.Now().UnixNano()) var wg sync.WaitGroup errChan := make(chan error, 10) // Buffered channel untuk mengumpulkan kesalahan items := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} wg.Add(len(items)) for i, item := range items { go processItem(i+1, item, &wg, errChan) } done := make(chan bool) go func() { wg.Wait() close(done) close(errChan) }() select { case <-done: fmt.Println("Semua goroutine selesai (atau gagal).") case <-time.After(time.Second * 5): fmt.Println("Timeout: Beberapa goroutine tidak selesai dalam jangka waktu.") } for err := range errChan { fmt.Println("Kesalahan:", err) } fmt.Println("Program berakhir.") } ```

Contoh ini mendemonstrasikan:

• Menunggu koleksi goroutine dinamis.
• Penanganan kesalahan menggunakan channel.
• Mengimplementasikan timeout menggunakan select.

8. Kesimpulan

sync.WaitGroup adalah alat yang ampuh untuk menyinkronkan goroutine di Go. Ini memungkinkan Anda untuk menunggu koleksi goroutine untuk menyelesaikan eksekusi mereka, memastikan bahwa semua pekerjaan konkuren selesai sebelum melanjutkan. Dengan memahami mekanisme internal sync.WaitGroup dan praktik terbaik untuk menggunakannya, Anda dapat menulis kode konkuren yang efisien dan aman.

Dalam posting blog ini, kita telah membahas dasar-dasar sync.WaitGroup, kode sumbernya, kasus penggunaan tingkat lanjut, pertimbangan kinerja, dan perangkap umum. Dengan pengetahuan ini, Anda diperlengkapi dengan baik untuk menggunakan sync.WaitGroup secara efektif dalam aplikasi Go Anda.

Ingatlah untuk selalu menambahkan ke WaitGroup sebelum meluncurkan goroutine, menggunakan defer wg.Done() untuk memastikan itu dipanggil, dan menggunakan mekanisme sinkronisasi lain, seperti mutexes, untuk melindungi variabel bersama dari kondisi race. Dengan mengikuti praktik terbaik ini, Anda dapat menulis kode konkuren yang kuat dan andal di Go.