Go Academy · Pelajaran

Pola Fan-in dan Fan-out

Menggabungkan beberapa channel dan mendistribusikan pekerjaan

Pelajaran 3 dari 413 langkah

Pola Fan-in dan Fan-out 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.

Apa itu Pendistribusian?

Pendistribusian membagi pekerjaan dari satu kanal ke beberapa rutin Go, sehingga pemrosesan dapat dilakukan secara paralel. Setiap pekerja menerima data dari kanal masukan yang sama.

Contoh Pendistribusian

Jalankan N pekerja yang semuanya membaca dari kanal jobs bersama:

func fanOut(jobs <-chan Job, n int) {
    for i := 0; i < n; i++ {
        go func() {
            for job := range jobs {
                process(job)
            }
        }()
    }
}

Apa itu Penggabungan?

Penggabungan menyatukan beberapa kanal menjadi satu, sehingga satu konsumen dapat membaca hasil dari banyak produsen.

Penggabungan dengan Rutin Go

Jalankan satu rutin Go untuk setiap kanal masukan; setiap rutin Go meneruskan nilai ke kanal keluaran bersama.

func fanIn(cs ...<-chan int) <-chan int {
    out := make(chan int)
    var wg sync.WaitGroup
    for _, c := range cs {
        wg.Add(1)
        go func(ch <-chan int) {
            defer wg.Done()
            for v := range ch { out <- v }
        }(c)
    }
    go func() { wg.Wait(); close(out) }()
    return out
}

Penggabungan dengan Pemilihan

Untuk jumlah kanal masukan yang tetap, perulangan pemilihan lebih sederhana daripada menjalankan satu rutin Go untuk setiap kanal.

func merge(a, b <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for a != nil || b != nil {
            select {
            case v, ok := <-a: if !ok { a = nil } else { out <- v }
            case v, ok := <-b: if !ok { b = nil } else { out <- v }
            }
        }
    }()
    return out
}

Tahap Alur Pemrosesan

Gabungkan pendistribusian dan penggabungan untuk membangun tahap alur pemrosesan: satu kanal masukan, N pekerja paralel, dan satu kanal keluaran yang digabungkan.

func parallelStage(in <-chan Work, n int) <-chan Result {
    outs := make([]<-chan Result, n)
    for i := 0; i < n; i++ {
        outs[i] = worker(in)
    }
    return fanIn(outs...)
}

Menutup Kanal dengan Rapi

Pengirim menutup kanal; penerima mendeteksi penutupan melalui bentuk penerimaan dua nilai atau dengan melakukan iterasi. Jangan pernah menutup kanal dari sisi penerima.

for v := range in { // exits when in is closed
    process(v)
}

Koordinasi WaitGroup

Gunakan sync.WaitGroup untuk mengetahui kapan semua pekerja pendistribusian selesai, lalu tutup kanal keluaran agar konsumen berikutnya dapat menyelesaikan pekerjaannya.

Tekanan Balik

Gunakan kanal berpenyangga di antara tahap alur pemrosesan untuk menyerap lonjakan. Tentukan ukuran penyangga berdasarkan perbedaan latensi yang diharapkan antara produsen dan konsumen.

out := make(chan Result, 100) // buffer absorbs bursts

Penerusan Galat

Bungkus hasil dalam struktur yang membawa nilai dan galat, sehingga galat mengalir melalui alur pemrosesan bersama data tanpa menyebabkan kepanikan.

type Result struct {
    Value int
    Err   error
}

Pembatalan Konteks

Teruskan konteks melalui tahap-tahap alur pemrosesan dan periksa ctx.Done() di setiap tahap agar seluruh alur pemrosesan berhenti saat dibatalkan.

case <-ctx.Done():
    return ctx.Err()

Pemeriksaan Singkat

Dalam pola penggabungan, apa yang menutup kanal keluaran yang telah digabungkan?

Jawab di pelajaran interaktif

Ringkasan: Penggabungan dan Pendistribusian

Poin penting:

Pendistribusian: beberapa pekerja membaca dari satu kanal
Penggabungan: satu rutin Go untuk setiap sumber menyatukan data ke satu kanal keluaran
WaitGroup mengoordinasikan penutupan kanal yang telah digabungkan
Gunakan konteks untuk pembatalan; kanal berpenyangga untuk tekanan balik

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 “Pola Fan-in dan Fan-out” gratis?

Ya — teks lengkap “Pola Fan-in dan Fan-out” 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 Fan-in dan Fan-out”?

Menggabungkan beberapa channel dan mendistribusikan pekerjaan 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 “Pola Fan-in dan Fan-out” 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