mpsc Kanalları
İş parçacıkları arasında gönderin
mpsc Kanalları, CoddyKit'te ücretsiz bir Learn Rust Coding dersidir. Bu, 4 dersinin 1. 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.
Kanal Nedir?
Kanal, değerleri bir iş parçacığından diğerine göndermek için kullanılan tek yönlü bir borudur. Rust'ın standart kitaplığı, mpsc'nin çoklu üretici, tek tüketici anlamına geldiği std::sync::mpsc yapısını sunar.
- Gönderici tarafı değerleri içeri iter.
- Alıcı tarafı değerleri dışarı çeker.
Kanallar, iş parçacıklarının belleği doğrudan paylaşmak yerine iletileri aktararak iletişim kurmasını sağlar; bu da birçok veri yarışını önler.
Kanal Oluşturma
Bir (Sender, Receiver) demeti almak için mpsc::channel() çağrısını yapın. Burada, oluşturulan bir iş parçacığından ana iş parçacığına tek bir değer gönderiyoruz.
use std::sync::mpsc;
use std::thread;
fn main() {
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
tx.send(42).unwrap();
});
let received = rx.recv().unwrap();
println!("Got: {}", received);
}send ve recv
tx.send(value) bir Result döndürür: yalnızca alıcı bırakılmışsa başarısız olur. rx.recv(), bir değer gelene kadar engellenir; tüm göndericiler ortadan kalktığında Err döndürür.
send, değerin sahipliğini kanala taşır.recv, diğer tarafta sahipliği devralır.
use std::sync::mpsc;
use std::thread;
fn main() {
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
let msg = String::from("hello from thread");
tx.send(msg).unwrap();
});
let text = rx.recv().unwrap();
println!("{}", text);
}Sahiplik Kanal Üzerinden Taşınır
send değeri değer olarak aldığı için gönderdikten sonra onu kullanamazsınız. Bu derleme zamanı kuralı, artık başka bir iş parçacığına ait olan verilere hiçbir iş parçacığının geçersiz bir başvuru tutmamasını garanti eder.
Aşağıda, send işleminden sonra msg yazdırılmaya çalışılsaydı derleme hatası oluşurdu; bu nedenle onu yalnızca bir kez kullanıyoruz.
use std::sync::mpsc;
use std::thread;
fn main() {
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
let data = vec![1, 2, 3];
tx.send(data).unwrap();
// data is moved; cannot use it here
});
let v = rx.recv().unwrap();
println!("Sum: {}", v.iter().sum::<i32>());
}Alıcı Üzerinde Yineleme
Bir Receiver, IntoIterator uygular. Üzerinde döngü kurulduğunda, kanal kapanana kadar (tüm göndericiler bırakılana kadar) her değeri üretir. Bu, bir ileti akışını tüketmenin Rust'taki alışılmış yoludur.
use std::sync::mpsc;
use std::thread;
fn main() {
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
for i in 1..=3 {
tx.send(i).unwrap();
}
});
for received in rx {
println!("Received: {}", received);
}
}clone ile Birden Çok Üretici
mpsc'deki mp, birden çok göndericiye sahip olabileceğiniz anlamına gelir. Sender'ı clone edin ve her iş parçacığına bir kopya verin. Alıcı, tüm kopyalar bırakılana kadar her şeyi toplar.
use std::sync::mpsc;
use std::thread;
fn main() {
let (tx, rx) = mpsc::channel();
let tx2 = tx.clone();
thread::spawn(move || { tx.send("from A").unwrap(); });
thread::spawn(move || { tx2.send("from B").unwrap(); });
for msg in rx {
println!("{}", msg);
}
}Kanalın Kapanma Kuralları
Tüm göndericiler bırakıldığında alıcı döngüsü otomatik olarak sona erer. Tek bir Sender bile canlı kalırsa for msg in rx, daha fazla ileti beklerken sonsuza kadar engellenir. Döngünün tamamlanabilmesi için göndericileri her zaman doğru şekilde bırakın veya bir kapsam içine alın.
use std::sync::mpsc;
use std::thread;
fn main() {
let (tx, rx) = mpsc::channel();
let handle = thread::spawn(move || {
for i in 0..3 {
tx.send(i * 10).unwrap();
}
// tx dropped here, closing the channel
});
handle.join().unwrap();
let total: i32 = rx.iter().sum();
println!("Total: {}", total);
}Engellemesiz Okumalar için try_recv
recv engellenir, ancak try_recv bir Result ile hemen döner. Bir ileti hazırsa Ok(value), kanal boşsa veya bağlantısı kesilmişse Err verir. Başka işleri yapmaya devam etmesi gereken olay döngülerinde kullanışlıdır.
use std::sync::mpsc;
use std::thread;
use std::time::Duration;
fn main() {
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
thread::sleep(Duration::from_millis(50));
tx.send("ready").unwrap();
});
loop {
match rx.try_recv() {
Ok(msg) => { println!("{}", msg); break; }
Err(_) => println!("waiting..."),
}
thread::sleep(Duration::from_millis(20));
}
}Özel Türler Gönderme
Send olan her tür, kendi yapı ve enum'larınız da dahil olmak üzere bir kanaldan geçebilir. Enum'lar, bir çalışan protokolündeki farklı ileti türlerini modellemek için oldukça uygundur.
use std::sync::mpsc;
use std::thread;
enum Job {
Print(String),
Add(i32, i32),
}
fn main() {
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
tx.send(Job::Print(String::from("hi"))).unwrap();
tx.send(Job::Add(2, 3)).unwrap();
});
for job in rx {
match job {
Job::Print(s) => println!("print: {}", s),
Job::Add(a, b) => println!("add: {}", a + b),
}
}
}sync_channel ve Geri Basınç
mpsc::sync_channel(n), arabellek boyutu n olan sınırlı bir kanal oluşturur. Arabellek dolduğunda send, yer açılana kadar engellenir. Bu, geri basınç sağlayarak hızlı bir üreticinin yavaş bir tüketiciyi aşırı yüklemesini önler.
sync_channel(0)bir buluşma kanalıdır: send ve recv buluşmalıdır.
use std::sync::mpsc;
use std::thread;
fn main() {
let (tx, rx) = mpsc::sync_channel(2);
thread::spawn(move || {
for i in 1..=4 {
tx.send(i).unwrap();
println!("sent {}", i);
}
});
for v in rx {
println!("got {}", v);
}
}Basit Bir Çalışan Deseni
Kanallar, üretici/tüketici deseninde çok etkilidir: bir iş parçacığı iş öğeleri üretir, diğeri bunları tüketip işler. Burada ana iş parçacığı sayıları üretir; bir çalışan da her birinin karesini alır ve sonucu ikinci bir kanal üzerinden geri bildirir.
use std::sync::mpsc;
use std::thread;
fn main() {
let (job_tx, job_rx) = mpsc::channel();
let (res_tx, res_rx) = mpsc::channel();
thread::spawn(move || {
for n in job_rx {
res_tx.send(n * n).unwrap();
}
});
for n in 1..=4 {
job_tx.send(n).unwrap();
}
drop(job_tx);
for r in res_rx {
println!("square: {}", r);
}
}Hızlı Kontrol
mpsc kanallarını ne kadar anladığınızı test edin.
Özet
mpsc kanallarının temellerini öğrendiniz:
mpsc::channel(), bir(Sender, Receiver)çifti döndürür.sendbir değeri içeri taşır;recvonu almak için engellenir.- Bir alıcı üzerinde yineleme yapmak, tüm göndericiler bırakılana kadar iletileri tüketir.
- Birden çok üretici için
Sender'ı clone edin. try_recvengellemesizdir;sync_channel(n)sınırlı geri basınç ekler.
Kanallar, sahipliği aktararak iş parçacıklarının belleği paylaşmadan verileri güvenli biçimde paylaşmasını sağlar.
Sıkça Sorulan Sorular
“mpsc Kanalları” dersi ücretsiz mi?
Evet — “mpsc 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.
“mpsc Kanalları” dersinde ne öğreneceğim?
İş parçacıkları arasında gönderin 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 1. dersidir.
“mpsc 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.