0Pricing
Learn Rust Coding · Pelajaran

Kanal Crossbeam

Kanal tingkat lanjut

Kanal Crossbeam adalah pelajaran Learn Rust Coding 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 Learn Rust Coding, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Melampaui std mpsc

Saluran mpsc standar memiliki satu konsumen: hanya satu penerima. Crate crossbeam-channel menyediakan saluran banyak produsen, banyak konsumen (mpmc) dengan lebih banyak fitur dan kinerja yang sering kali lebih baik.

Hal-hal penting:

  • Receiver yang dapat digandakan, bukan hanya pengirim.
  • Makro select! yang canggih untuk menunggu pada banyak saluran.
  • Saluran berbatas, tak berbatas, dan saluran khusus seperti detak.

Menambahkan Dependensi

Crossbeam adalah crate eksternal, jadi tambahkan ke Cargo.toml:

[dependencies]
crossbeam-channel = "0.5"

Kemudian impor fungsi-fungsinya. Karena ini memerlukan Cargo dan crate eksternal, cuplikan di sini menjelaskan API, bukan berjalan secara mandiri.

// Cargo.toml
// [dependencies]
// crossbeam-channel = "0.5"

use crossbeam_channel::unbounded;

fn main() {
    let (s, r) = unbounded();
    s.send("hello").unwrap();
    println!("{}", r.recv().unwrap());
}

tak berbatas dan berbatas

Crossbeam menyediakan dua konstruktor utama:

  • unbounded() berkembang sesuai kebutuhan; send tidak pernah menunggu.
  • bounded(cap) memiliki penyangga tetap; send menunggu ketika penyangga penuh, sehingga menyediakan tekanan balik.

Saluran bounded(0) adalah saluran pertemuan, tempat send dan recv menyerahkan data secara langsung.

use crossbeam_channel::bounded;
use std::thread;

fn main() {
    let (s, r) = bounded(2);
    thread::spawn(move || {
        for i in 1..=3 {
            s.send(i).unwrap();
        }
    });
    while let Ok(v) = r.recv() {
        println!("got {}", v);
    }
}

Beberapa Konsumen

Keunggulan utamanya: Anda dapat menggandakan Receiver. Beberapa utas pekerja dapat mengambil pesan dari saluran yang sama, dan setiap pesan masuk tepat ke salah satu dari mereka. Inilah dasar kumpulan utas yang mencuri pekerjaan.

use crossbeam_channel::unbounded;
use std::thread;

fn main() {
    let (s, r) = unbounded();
    let mut workers = vec![];
    for id in 0..3 {
        let rx = r.clone();
        workers.push(thread::spawn(move || {
            while let Ok(job) = rx.recv() {
                println!("worker {} got job {}", id, job);
            }
        }));
    }
    for job in 0..6 { s.send(job).unwrap(); }
    drop(s);
    for w in workers { w.join().unwrap(); }
}

Makro select!

select! memungkinkan satu utas menunggu beberapa operasi saluran dan bertindak pada operasi yang siap terlebih dahulu. Makro ini seperti match atas peristiwa saluran, ideal untuk menggabungkan masukan dari beberapa sumber.

use crossbeam_channel::{unbounded, select};
use std::thread;

fn main() {
    let (s1, r1) = unbounded();
    let (s2, r2) = unbounded();
    thread::spawn(move || { s1.send("from one").unwrap(); });
    thread::spawn(move || { s2.send("from two").unwrap(); });
    for _ in 0..2 {
        select! {
            recv(r1) -> msg => println!("r1: {}", msg.unwrap()),
            recv(r2) -> msg => println!("r2: {}", msg.unwrap()),
        }
    }
}

Batas Waktu dengan select!

select! mendukung cabang default dan cabang pengatur waktu recv(after(duration)), sehingga Anda dapat berhenti menunggu setelah batas waktu alih-alih menunggu selamanya. Hal ini penting untuk sistem yang responsif.

use crossbeam_channel::{unbounded, select, after};
use std::time::Duration;

fn main() {
    let (_s, r) = unbounded::<i32>();
    select! {
        recv(r) -> msg => println!("received {:?}", msg),
        recv(after(Duration::from_millis(100))) -> _ => {
            println!("timed out waiting for a message");
        }
    }
}

try_send dan try_recv

Seperti pustaka standar, crossbeam menyediakan varian yang tidak menunggu. try_send langsung gagal jika saluran berbatas penuh; try_recv langsung gagal jika belum ada pesan yang siap. Keduanya mengembalikan galat deskriptif yang dapat Anda cocokkan.

use crossbeam_channel::{bounded, TrySendError};

fn main() {
    let (s, _r) = bounded(1);
    s.send(1).unwrap();
    match s.try_send(2) {
        Ok(()) => println!("sent"),
        Err(TrySendError::Full(v)) => println!("full, kept {}", v),
        Err(TrySendError::Disconnected(v)) => println!("closed, kept {}", v),
    }
}

tick dan Pekerjaan Berkala

Fungsi tick(duration) mengembalikan penerima yang mengirimkan pesan pada interval tetap. Gabungkan dengan select! untuk menjalankan tugas berkala bersama saluran lain, seperti detak jantung atau putaran pemantauan.

use crossbeam_channel::{tick, select};
use std::time::Duration;

fn main() {
    let ticker = tick(Duration::from_millis(50));
    let mut count = 0;
    while count < 3 {
        select! {
            recv(ticker) -> _ => {
                count += 1;
                println!("tick {}", count);
            }
        }
    }
}

Alur Pemrosesan Bertahap

Crossbeam sangat unggul untuk membangun alur pemrosesan: tahap pertama menghasilkan data, tahap kedua mengubahnya, dan tahap ketiga menggunakannya. Setiap tahap berjalan di thread-nya sendiri yang terhubung melalui channel, dan receiver yang di-clone memungkinkan Anda menambah jumlah worker pada tahap mana pun.

use crossbeam_channel::unbounded;
use std::thread;

fn main() {
    let (in_s, in_r) = unbounded();
    let (out_s, out_r) = unbounded();
    thread::spawn(move || {
        for n in in_r { out_s.send(n * n).unwrap(); }
    });
    for n in 1..=4 { in_s.send(n).unwrap(); }
    drop(in_s);
    for sq in out_r { println!("square: {}", sq); }
}

Saat Crossbeam Lebih Unggul daripada std

Gunakan crossbeam-channel ketika Anda memerlukan:

  • Beberapa consumer yang berbagi satu antrean (kumpulan worker).
  • select! pada banyak channel dengan batas waktu.
  • Timer berkala melalui tick yang terintegrasi dengan pemilihan.

Untuk pipe sederhana dengan satu producer dan satu consumer, mpsc standar sudah memadai dan tidak memerlukan dependensi.

Channel Ditutup dengan Menghapusnya

Sama seperti std, channel Crossbeam ditutup ketika semua sender (di sisi receiver) atau semua receiver (di sisi sender) dihapus. Iterasi pada receiver berakhir setelah sender terakhir dihapus. Selalu gunakan drop atau batasi cakupan sender agar loop worker dapat berakhir dengan baik.

use crossbeam_channel::unbounded;
use std::thread;

fn main() {
    let (s, r) = unbounded();
    let h = thread::spawn(move || {
        let total: i32 = r.iter().sum();
        println!("total: {}", total);
    });
    for i in 1..=5 { s.send(i).unwrap(); }
    drop(s); // closes channel so the loop ends
    h.join().unwrap();
}

Pemeriksaan Singkat

Uji pemahaman Anda tentang channel Crossbeam.

Ringkasan

Anda telah mempelajari channel Crossbeam:

  • Channel ini bersifat mpmc: sender dan receiver sama-sama dapat di-clone.
  • unbounded() dan bounded(n) mengatur buffering dan tekanan balik.
  • select! menunggu beberapa channel, dengan batas waktu melalui after dan tick berkala.
  • try_send/try_recv tidak memblokir.
  • Gunakan Crossbeam untuk kumpulan worker dan alur pemrosesan yang kompleks; gunakan std mpsc untuk pipe sederhana.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Kanal Crossbeam” gratis?

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

Apa yang akan aku pelajari di “Kanal Crossbeam”?

Kanal tingkat lanjut Kamu berlatih Learn Rust Coding 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 Learn Rust Coding?

Tidak diperlukan pengalaman sebelumnya. Learn Rust Coding 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 “Kanal Crossbeam” 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 Learn Rust Coding ini?

Ya. Setiap pelajaran Learn Rust Coding 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. Kanal mpsc
  2. Berbagi State dengan Arc/Mutex
  3. Thread Berscope
  4. Kanal Crossbeam
← Kembali ke Learn Rust Coding