PricingLoginStart free
Learn Rust Coding · Ders

Crossbeam Kanalları

Gelişmiş kanallar

4. ders / 413 adım

Crossbeam Kanalları, CoddyKit'te ücretsiz bir Learn Rust Coding dersidir. Bu, 4 dersinin 4. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Learn Rust Coding öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Learn Rust Coding kursu toplamda 4 dersten oluşur.

std mpsc'nin Ötesi

Standart mpsc kanalı tek tüketicilidir: yalnızca bir alıcısı vardır. crossbeam-channel paketi, daha fazla özellik ve çoğu zaman daha iyi performans sunan çok üreticili, çok tüketicili (mpmc) kanallar sağlar.

Öne çıkanlar:

  • Yalnızca göndericiler değil, klonlanabilir Receiver değerleri de vardır.
  • Birçok kanalı beklemek için güçlü bir select! makrosu.
  • Sınırlı, sınırsız ve tikler gibi özel kanallar.

Bağımlılığı Ekleme

Crossbeam harici bir pakettir; bu nedenle onu Cargo.toml dosyasına ekleyin:

[dependencies]
crossbeam-channel = "0.5"

Ardından işlevlerini içe aktarın. Bunun için Cargo ve harici bir paket gerektiğinden, buradaki parçacıklar tek başına çalışmak yerine API'yi gösterir.

// 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());
}

unbounded ve bounded

Crossbeam iki ana oluşturucu sunar:

  • unbounded() gerektiğinde büyür; send hiçbir zaman engellenmez.
  • bounded(cap) sabit boyutlu bir arabelleğe sahiptir; arabellek doluyken send engellenir ve bu da geri basınç sağlar.

bounded(0) kanalı, send ve recv işlemlerinin doğrudan el değiştirdiği bir buluşma kanalıdır.

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);
    }
}

Birden Çok Tüketici

Temel avantaj şudur: Receiver'ı klonlayabilirsiniz. Birden çok çalışan iş parçacığı aynı kanaldan veri çekebilir ve her ileti bunlardan tam olarak birine gider. Bu, iş çalan bir iş parçacığı havuzunun temelini oluşturur.

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(); }
}

select! Makrosu

select!, bir iş parçacığının birden çok kanal işlemini beklemesini ve ilk hazır olan işlem üzerinde çalışmasını sağlar. Bu, kanal olayları üzerinde kullanılan bir match gibidir ve çeşitli kaynaklardan gelen girdileri birleştirmek için idealdir.

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()),
        }
    }
}

select! ile Zaman Aşımları

select!, bir default kolunu ve bir recv(after(duration)) zamanlayıcı kolunu destekler. Böylece sonsuza kadar engellenmek yerine bir zaman aşımından sonra beklemekten vazgeçebilirsiniz. Bu, yanıt verebilir sistemler için zorunludur.

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 ve try_recv

Standart kitaplıkta olduğu gibi crossbeam de engellemesiz çeşitler sağlar. try_send, sınırlı bir kanal doluysa hemen başarısız olur; try_recv ise hazır ileti yoksa hemen başarısız olur. Her ikisi de üzerinde eşleştirme yapabileceğiniz açıklayıcı bir hata döndürür.

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 ve Periyodik Çalışma

tick(duration) işlevi, sabit aralıklarla bir ileti sağlayan bir alıcı döndürür. Bunu select! ile birleştirerek kalp atışı veya yoklama döngüsü gibi periyodik görevleri diğer kanalların yanında çalıştırabilirsiniz.

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);
            }
        }
    }
}

Aşamalardan Oluşan Bir Pipeline

Crossbeam pipeline oluşturma konusunda çok başarılıdır: birinci aşama üretir, ikinci aşama dönüştürür, üçüncü aşama tüketir. Her aşama, kanallarla birbirine bağlanan kendi iş parçacığında çalışır ve klonlanmış alıcılar herhangi bir aşamayı birden çok çalışana ölçeklendirmenizi sağlar.

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); }
}

Crossbeam std'yi Ne Zaman Geçer

Şu ihtiyaçlarınız olduğunda crossbeam-channel kullanın:

  • Tek bir kuyruğu paylaşan birden çok tüketici (çalışan havuzları).
  • Zaman aşımlarıyla birlikte birçok kanal üzerinde select!.
  • Seçime entegre edilmiş tick aracılığıyla periyodik zamanlayıcılar.

Basit bir tek üreticili-tek tüketicili boru için standart mpsc yeterlidir ve bağımlılık gerektirmez.

Kanallar Bırakılarak Kapatılır

std'de olduğu gibi crossbeam kanalları da alıcı tarafı için tüm göndericiler veya gönderici tarafı için tüm alıcılar bırakıldığında kapanır. Bir alıcı üzerinde yineleme, son gönderici bırakıldıktan sonra sona erer. Çalışan döngülerinin temiz biçimde çıkabilmesi için göndericilerinizi her zaman drop edin veya kapsam içine alın.

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();
}

Hızlı Kontrol

Crossbeam kanalları konusundaki anlayışınızı test edin.

İnteraktif derste cevapla

Özet

crossbeam kanallarını incelediniz:

  • Bunlar mpmc'dir: hem göndericiler hem de alıcılar klonlanabilir.
  • unbounded() ve bounded(n), arabelleğe almayı ve geri basıncı kontrol eder.
  • select!, after aracılığıyla zaman aşımları ve tick aracılığıyla periyodik işlemlerle birlikte birden çok kanalı bekler.
  • try_send/try_recv engellemesizdir.
  • Çalışan havuzları ve karmaşık pipeline yapıları için crossbeam'i; basit borular için std mpsc'yi kullanın.
Başlamak ücretsiz

Yapay zeka eğitmeniyle Rust öğren — ücretsiz

Tarayıcında gerçek kod yaz ve çalıştır, 7/24 yapay zeka eğitmeninden anında yardım al; web'de ya da uygulamada kaldığın yerden devam et.

Kurslar
39
Dersler
144
Ücretsiz öğrenmeye başlaTüm kursu görüntüle

Sıkça Sorulan Sorular

“Crossbeam Kanalları” dersi ücretsiz mi?

Evet — “Crossbeam Kanalları” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Learn Rust Coding kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Learn Rust Coding kursu toplamda 4 dersten oluşur.

“Crossbeam Kanalları” dersinde ne öğreneceğim?

Gelişmiş kanallar Learn Rust Coding ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Learn Rust Coding öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Learn Rust Coding, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 4. dersidir.

“Crossbeam Kanalları” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Learn Rust Coding dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Learn Rust Coding dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. mpsc Kanalları
  2. Durumu Arc/Mutex ile Paylaşma
  3. Kapsamlı İş Parçacıkları
  4. Crossbeam Kanalları
← Learn Rust Coding Sayfasına Dön