0Pricing
Go Academy · Pelajaran

Pola Pipeline dan Tahap

Menyusun pipeline konkuren mult itahap

Pola Pipeline dan Tahap adalah pelajaran Go Academy gratis di CoddyKit. Ini adalah pelajaran 1 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 alur pemrosesan?

Alur pemrosesan konkuren adalah rangkaian Stage yang dihubungkan oleh saluran. Setiap Stage menerima nilai dari tahap sebelumnya, mengubahnya, lalu mengirim hasilnya ke tahap berikutnya, sehingga setiap Stage dapat berjalan secara konkuren.

Alur pemrosesan tiga tahap sederhana

Generate → transformasi → konsumsi:

func generate(nums ...int) <-chan int {
    out := make(chan int)
    go func() { defer close(out); for _, n := range nums { out <- n } }()
    return out
}
func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() { defer close(out); for n := range in { out <- n*n } }()
    return out
}

for v := range square(generate(2, 3, 4)) {
    fmt.Println(v) // 4, 9, 16
}

Pola Stage

Setiap Stage adalah fungsi yang menerima saluran masukan dan mengembalikan saluran keluaran. Stage dapat dikomposisikan dengan rapi dan diparalelkan secara mandiri.

Percabangan dalam alur pemrosesan

Gandakan sebuah Stage menjadi N goroutine untuk memparalelkan pekerjaan yang dibatasi CPU:

func parallelSquare(in <-chan int, n int) <-chan int {
    outs := make([]<-chan int, n)
    for i := 0; i < n; i++ {
        outs[i] = square(in) // all read from same in
    }
    return merge(outs...)
}

Pembatalan dengan konteks

Teruskan konteks ke setiap Stage. Saat konteks dibatalkan, Stage berhenti membaca dan menutup saluran keluarannya, sehingga seluruh alur pemrosesan terkuras.

func stage(ctx context.Context, in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for {
            select {
            case v, ok := <-in:
                if !ok { return }
                select {
                case out <- process(v):
                case <-ctx.Done(): return
                }
            case <-ctx.Done(): return
            }
        }
    }()
    return out
}

Tekanan balik

Gunakan saluran berbuffer di antara Stage untuk memisahkan kecepatan produsen dan konsumen. Tanpa buffering, Stage yang lambat akan menghentikan seluruh alur pemrosesan.

out := make(chan Result, 50) // buffer 50 results

Propagasi galat

Bungkus nilai dalam struktur hasil untuk meneruskan galat melalui alur pemrosesan tanpa memicu panic:

type item struct { val int; err error }

Pola saluran Done

Gunakan saluran Done sebagai alternatif konteks untuk alur pemrosesan yang lebih sederhana. Tutup Done untuk memberi sinyal agar semua Stage berhenti.

done := make(chan struct{})
defer close(done)

Jaminan urutan

Alur pemrosesan sederhana mempertahankan urutan jika setiap Stage berjalan berurutan. Stage yang diparalelkan tidak mempertahankan urutan — gunakan bidang indeks untuk mengurutkan ulang hasil di tahap berikutnya jika diperlukan.

Alur pemrosesan dengan WaitGroup

Stage terakhir tidak perlu menutup saluran — cukup lakukan iterasi terhadapnya. Gunakan WaitGroup dalam fan-in untuk menutup saluran gabungan setelah semua goroutine produsen selesai.

Penggunaan di dunia nyata

Penerapan umum alur pemrosesan: pemrosesan data ETL, pengubahan ukuran gambar, penguraian log, sistem pembangunan, dan penangan permintaan berbasis aliran.

Pemeriksaan Cepat

Bagaimana cara meneruskan pembatalan melalui alur pemrosesan yang terdiri dari beberapa tahap?

Rangkuman: Pola Alur Pemrosesan

Poin penting:

  • Stage: func(in <-chan T) <-chan U — komposisikan untuk alur pemrosesan
  • Pembatalan melalui konteks; tekanan balik melalui saluran berbuffer
  • Percabangan dalam Stage untuk paralelisme
  • Bungkus nilai dalam struktur hasil untuk propagasi galat

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pola Pipeline dan Tahap” gratis?

Ya — teks lengkap “Pola Pipeline dan Tahap” 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 Pipeline dan Tahap”?

Menyusun pipeline konkuren mult itahap 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 1 dari 4.

Berapa lama pelajaran “Pola Pipeline dan Tahap” 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

  1. Pola Pipeline dan Tahap
  2. errgroup untuk Penanganan Error Konkuren
  3. Pola Semaphore
  4. Deteksi Kebocoran dan Pembatalan
← Kembali ke Go Academy