Go Academy · Pelajaran

Throttling Goroutine

Kontrol konkurensi

Pelajaran 3 dari 413 langkah

Throttling Goroutine adalah pelajaran Go Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Go Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Go Academy mencakup 4 pelajaran total.

Membatasi Konkurensi

Terkadang Anda tidak membatasi jumlah operasi per detik, melainkan membatasi berapa banyak goroutine yang berjalan sekaligus. Ini membatasi beban simultan pada suatu sumber daya, terlepas dari waktunya.

Membatasi paralelisme
Melindungi kumpulan koneksi
Mencegah lonjakan penggunaan memori

Kanal Semaphore

Kanal berbuffer dapat berfungsi sebagai semaphore penghitung. Kapasitasnya sama dengan konkurensi maksimum. Akuisisi mengirim sebuah token; pelepasan menerima sebuah token.

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

Akuisisi dan Pelepasan

Sebelum memulai pekerjaan, kirim ke kanal untuk memperoleh slot (akan terblokir jika kanal penuh). Setelah selesai, terima dari kanal untuk melepaskannya sehingga slot tersedia bagi goroutine lain.

sem <- struct{}{}        // acquire
// do work
<-sem                    // release

Mengapa struct{}

Struct kosong struct{}{} menggunakan nol byte. Menggunakannya sebagai elemen kanal menjadikan semaphore murni sebagai sinyal tanpa membuang memori.

Membatasi Sebuah Perulangan

Jalankan satu goroutine untuk setiap tugas, tetapi kendalikan masing-masing dengan semaphore. Paling banyak cap goroutine yang mengerjakan pekerjaan sebenarnya secara bersamaan; sisanya terblokir saat akuisisi.

for _, task := range tasks {
    sem <- struct{}{}
    go func(t Task) {
        defer func() { <-sem }()
        process(t)
    }(t)
}

Menggabungkan dengan WaitGroup

Semaphore membatasi konkurensi, tetapi tidak memberi tahu Anda kapan semuanya selesai. Gabungkan dengan sync.WaitGroup untuk menunggu semua tugas selesai.

var wg sync.WaitGroup
wg.Add(1)
go func() {
    defer wg.Done()
    defer func() { <-sem }()
    process(t)
}()

Melepas dalam defer

Selalu lakukan pelepasan dalam defer agar slot tetap dibebaskan meskipun pekerjaan mengalami panic atau kembali lebih awal. Lupa melakukan pelepasan akan membocorkan slot dan pada akhirnya menyebabkan kebuntuan bagi akuisisi baru.

Eksekusi Terbatas yang Lengkap

Program ini menjalankan delapan tugas dengan paling banyak dua tugas secara bersamaan, serta mencetak waktu mulai dan selesai untuk menunjukkan penerapan batas tersebut.

package main

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

func main() {
    sem := make(chan struct{}, 2)
    var wg sync.WaitGroup
    for i := 0; i < 8; i++ {
        wg.Add(1)
        sem <- struct{}{}
        go func(id int) {
            defer wg.Done()
            defer func() { <-sem }()
            fmt.Println("start", id)
            time.Sleep(20 * time.Millisecond)
            fmt.Println("end", id)
        }(i)
    }
    wg.Wait()
    fmt.Println("done")
}

errgroup dengan SetLimit

Paket golang.org/x/sync/errgroup menyediakan SetLimit untuk membatasi sebuah grup dan meneruskan error pertama. Ini merupakan alternatif yang lebih rapi dalam banyak kasus, meskipun berupa paket eksternal.

Pembatasan dan Kumpulan Pekerja

Kumpulan pekerja menggunakan kembali sekumpulan goroutine tetap yang mengambil tugas dari antrean. Pembatasan dengan semaphore menjalankan satu goroutine per tugas, tetapi membatasi goroutine yang aktif. Kumpulan pekerja lebih hemat untuk jumlah tugas yang sangat besar; semaphore lebih mudah ditambahkan.

Memilih Batas

Untuk pemanggilan basis data, tetapkan batas pada atau di bawah ukuran kumpulan koneksi Anda. Untuk HTTP keluar, sesuaikan dengan batas koneksi host. Batas yang terlalu tinggi menyebabkan sumber daya habis; batas yang terlalu rendah menyia-nyiakan kapasitas.

Pemeriksaan Singkat

Uji pemahaman Anda tentang pembatasan.

Jawab di pelajaran interaktif

Ringkasan

Anda telah mempelajari pembatasan goroutine:

Kanal berbuffer berfungsi sebagai semaphore penghitung
Lakukan akuisisi dengan pengiriman, dan pelepasan dengan penerimaan dalam defer
Elemen struct{} menggunakan nol byte
Gabungkan dengan WaitGroup untuk menunggu penyelesaian
Sesuaikan ukuran batas dengan sumber daya yang dilindungi

Gratis untuk memulai

Belajar Go dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 51
Pelajaran: 203

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Throttling Goroutine” gratis?

Ya — teks lengkap “Throttling Goroutine” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Go Academy, upgrade ke CoddyKit PRO. Kursus Go Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Throttling Goroutine”?

Kontrol konkurensi Kamu berlatih Go Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Go Academy?

Tidak diperlukan pengalaman sebelumnya. Go Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Throttling Goroutine” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Go Academy ini?

Ya. Setiap pelajaran Go Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Go Academy