Go Academy · Pelajaran

Pola Kumpulan Worker

Membangun kumpulan worker goroutine berukuran tetap

Pola Kumpulan Worker adalah pelajaran Go Academy gratis di CoddyKit. Ini adalah pelajaran 4 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.

Apa itu Kumpulan Pekerja?

Kumpulan pekerja menyiapkan sejumlah tetap rutin Go yang memproses pekerjaan dari antrean bersama. Hal ini membatasi konkurensi dan mencegah habisnya sumber daya akibat pembuatan rutin Go tanpa batas.

Implementasi Dasar

Buat kanal pekerjaan dan N rutin Go yang semuanya membaca darinya:

func workerPool(n int, jobs <-chan Job, results chan<- Result) {
    var wg sync.WaitGroup
    for i := 0; i < n; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for job := range jobs {
                results <- process(job)
            }
        }()
    }
    wg.Wait()
    close(results)
}

Mengirim Pekerjaan

Kirim semua pekerjaan ke kanal, lalu tutup kanal tersebut. Para pekerja akan memproses semua pekerjaan dan keluar dari perulangannya saat kanal ditutup.

jobs := make(chan Job, 100)
for _, j := range allJobs {
    jobs <- j
}
close(jobs) // signals workers to stop after draining

Mengumpulkan Hasil

Baca hasil secara bersamaan saat mengirim pekerjaan. Gunakan satu rutin Go untuk kumpulan pekerja agar pengumpulan hasil tidak mengalami kebuntuan saat pengiriman pekerjaan.

results := make(chan Result, 100)
go workerPool(5, jobs, results)
for r := range results {
    collect(r)
}

Menyesuaikan Ukuran Kumpulan

Untuk pekerjaan yang terikat CPU, tetapkan ukuran kumpulan ke runtime.NumCPU(). Untuk pekerjaan yang terikat operasi I/O, pengali yang lebih besar (misalnya 10×) dapat memanfaatkan waktu tunggu. Lakukan pembuatan profil untuk menemukan titik optimal.

n := runtime.NumCPU()
if ioHeavy { n = runtime.NumCPU() * 10 }

Menambahkan Pembatalan Konteks

Teruskan konteks kepada pekerja agar mereka berhenti lebih awal saat dibatalkan:

for {
    select {
    case job, ok := <-jobs:
        if !ok { return }
        results <- process(ctx, job)
    case <-ctx.Done():
        return
    }
}

Alternatif Semafor

Alih-alih menggunakan kumpulan rutin Go tetap, gunakan kanal berpenyangga sebagai semafor untuk membatasi jumlah rutin Go yang berjalan bersamaan, sambil tetap membuat satu rutin Go untuk setiap pekerjaan.

sem := make(chan struct{}, 10)
for _, job := range jobs {
    sem <- struct{}{}
    go func(j Job) {
        defer func() { <-sem }()
        process(j)
    }(job)
}

Penanganan Galat

Kembalikan galat bersama hasil menggunakan struktur hasil. Batalkan konteks saat galat pertama terjadi, atau kumpulkan semua galat untuk laporan akhir.

type Result struct{ Val int; Err error }

Ukuran Kumpulan Dinamis

Untuk kumpulan adaptif, gunakan golang.org/x/sync/semaphore, yang memungkinkan Anda memperoleh dan melepaskan sumber daya berbobot serta mendukung batas konkurensi dinamis.

Kumpulan Pekerja vs errgroup

golang.org/x/sync/errgroup menyediakan API yang lebih sederhana untuk menjalankan N rutin Go dan mengumpulkan galat pertama. Gunakan kumpulan pekerja jika Anda memerlukan sekumpulan pekerja tetap yang dapat digunakan kembali.

Penghentian Secara Tertib

Tutup kanal pekerjaan untuk memberi sinyal kepada pekerja. Setelah WaitGroup selesai, tutup hasil. Semua pengiriman pekerjaan yang tertunda harus dilakukan sebelum close(jobs).

Pemeriksaan Singkat

Bagaimana kumpulan pekerja memberi sinyal kepada pekerja untuk berhenti memproses?

Ringkasan: Kumpulan Pekerja

Poin penting:

N rutin Go tetap membaca dari satu kanal pekerjaan
Tutup kanal pekerjaan untuk memberi sinyal kepada pekerja agar menyelesaikan tugas
WaitGroup melacak penyelesaian; tutup hasil setelah selesai
Terikat CPU: ukuran kumpulan ≈ NumCPU; terikat operasi I/O: lebih besar

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pola Kumpulan Worker” gratis?

Ya — teks lengkap “Pola Kumpulan Worker” 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 “Pola Kumpulan Worker”?

Membangun kumpulan worker goroutine berukuran tetap 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 4 dari 4.

Berapa lama pelajaran “Pola Kumpulan Worker” 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