Birleştirme ve Sonuçları Toplama
İş parçacıklarını bekleyip çıktıyı toplayın.
Birleştirme ve Sonuçları Toplama, 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.
İş Parçacıklarına Neden Katılmalısınız?
İş parçacığı oluşturmak çalışmayı başlatır; ancak genellikle sonucuna veya en azından tamamlandığına dair kanıta ihtiyaç duyarsınız. Katılmak, beklemenin yoludur.
Bu derste tutamaçları toplayacak, onlara katılacak ve ürettikleri değerleri nihai bir yanıtta bir araya getireceksiniz.
join Bir Result Döndürür
join bir Result döndürür. Başarılı olduğunda kapanışın dönüş değerini, iş parçacığı paniğe kapıldığında ise bir Err içerir.
unwrap çağrısı değeri doğrudan verir; ancak iş parçacığı başarısız olursa paniği yeniden yayar.
use std::thread;
fn main() {
let h = thread::spawn(|| 7 * 6);
let value: i32 = h.join().unwrap();
println!("answer = {}", value);
}Önce Tüm Türelacıları Toplamak
İş parçacıklarını paralel çalıştırmak için herhangi birine katılmadan önce hepsini oluşturun. İlerledikçe her tutamacı bir vektöre ekleyin.
Oluşturma döngüsünün içinde katılırsanız her iş parçacığı sonraki başlamadan önce tamamlanır ve eşzamanlılığı kaybedersiniz.
use std::thread;
fn main() {
let handles: Vec<_> = (0..4)
.map(|i| thread::spawn(move || i * i))
.collect();
for h in handles {
println!("{}", h.join().unwrap());
}
}Sonuçları Bir Vec İçinde Toplamak
Her tutamaç için katılım sağlayıp döndürülen değerleri bir results vektörüne ekleyebilirsiniz.
Burada oluşturma sırası ve katılma sırası da sıfırdan üçe kadar olduğundan results vektörü öngörülebilir bir sırada oluşur.
use std::thread;
fn main() {
let handles: Vec<_> = (1..=4)
.map(|n| thread::spawn(move || n * 10))
.collect();
let results: Vec<i32> = handles
.into_iter()
.map(|h| h.join().unwrap())
.collect();
println!("{:?}", results);
}Paralel Sonuçları Toplamak
Sonuçları topladıktan sonra onları azaltabilirsiniz. Burada her iş parçacığı kısmi bir değer hesaplar ve main bunları toplar.
Bu map ve ardından reduce biçimi, yaygın bir paralel yaklaşımdır.
use std::thread;
fn main() {
let handles: Vec<_> = (1..=5)
.map(|n| thread::spawn(move || n * n))
.collect();
let total: i32 = handles
.into_iter()
.map(|h| h.join().unwrap())
.sum();
println!("total = {}", total);
}Çalışmayı Parçalara Bölmek
Daha büyük veriler için verileri parçalara ayırın ve her parçayı kendi iş parçacığına verin. Her iş parçacığı kısmi bir toplam döndürür.
Her parçayı sahip olunan bir Vec içine kopyalamak, iş parçacığının kendi dilimine güvenle sahip olmasını sağlar.
use std::thread;
fn main() {
let data: Vec<i32> = (1..=10).collect();
let handles: Vec<_> = data
.chunks(5)
.map(|c| { let c = c.to_vec(); thread::spawn(move || c.iter().sum::<i32>()) })
.collect();
let total: i32 = handles.into_iter().map(|h| h.join().unwrap()).sum();
println!("{}", total);
}İş Parçacığı Paniğini Yönetmek
Bir çalışanın paniğe kapılma olasılığı varsa unwrap'ı düşünmeden kullanmayın. Hata yolunu yönetmek için join'den gelen Result üzerinde eşleştirme yapın.
Bu, çalışanlardan biri başarısız olsa bile main iş parçacığının çalışmaya devam etmesini sağlar.
use std::thread;
fn main() {
let h = thread::spawn(|| {
if true { panic!("failed"); }
1
});
match h.join() {
Ok(v) => println!("got {}", v),
Err(_) => println!("thread panicked"),
}
}Paylaşılan Bir Vec İçinde Toplamak
Değerleri döndürmek yerine iş parçacıkları paylaşılan bir Arc<Mutex<Vec>> içine ekleme yapabilir. Bu durumda sıra belirli değildir.
Tüm iş parçacıklarına katıldıktan sonra toplanan her sonucu okumak için vektörün kilidini bir kez alın.
use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
let out = Arc::new(Mutex::new(vec![]));
let mut handles = vec![];
for i in 0..3 {
let o = Arc::clone(&out);
handles.push(thread::spawn(move || o.lock().unwrap().push(i)));
}
for h in handles { h.join().unwrap(); }
println!("{:?}", out.lock().unwrap());
}Kapsamlı İş Parçacıkları
thread::scope, iş parçacıklarının move veya Arc olmadan yerel verileri ödünç almasını sağlar. Kapsam, geri dönmeden önce tüm iş parçacıklarının tamamlanmasını garanti eder.
Bu, yığın verilerinin paralel olarak okunmasını kolay ve güvenli hâle getirir.
use std::thread;
fn main() {
let data = vec![1, 2, 3];
thread::scope(|s| {
s.spawn(|| println!("sum {}", data.iter().sum::<i32>()));
s.spawn(|| println!("len {}", data.len()));
});
}Sonuçları Kapsamdan Döndürmek
Kapsamlı iş parçacıkları da değerleri tutamaçları aracılığıyla döndürür. Sonuçları toplamak için kapsam içinde onlara katılın.
Kapsam tamamlanana kadar beklediğinden, ödünç alınan veriler tüm süre boyunca geçerli kalır.
use std::thread;
fn main() {
let nums = vec![4, 5, 6];
let total = thread::scope(|s| {
let h = s.spawn(|| nums.iter().sum::<i32>());
h.join().unwrap()
});
println!("total = {}", total);
}Katılmayı Unutmayın
Bir JoinHandle değerini katılmadan bırakırsanız iş parçacığı ayrılır. Çalışmaya devam eder; ancak sonucunu ve onu bekleme olanağını kaybedersiniz.
Süreç, ayrılmış iş parçacığı tamamlanmadan da sona erebilir. Sonuca veya tamamlanma bilgisine ihtiyaç duyduğunuzda katılın.
Hızlı Kontrol
İş parçacıklarına katılma ve sonuçları toplama konusundaki anlayışınızı sınayın.
Özet
join'in bir iş parçacığının değerini veya paniğini taşıyan bir Result döndürdüğünü öğrendiniz. Eşzamanlılığı korumak için önce tüm iş parçacıklarını oluşturun, ardından katılın.
Sonuçları bir Vec içinde toplayabilir, azaltabilir veya paylaşılan bir Arc<Mutex<Vec>> içine ekleyebilirsiniz. Kapsamlı iş parçacıkları yerel verileri güvenle ödünç alır; bir tutamacı bırakmak ise iş parçacığını ayırır.
Artık Rust'ta iş parçacıkları ve paylaşılan durum için temel araçlara sahipsiniz.
Sıkça Sorulan Sorular
“Birleştirme ve Sonuçları Toplama” dersi ücretsiz mi?
Evet — “Birleştirme ve Sonuçları Toplama” 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.
“Birleştirme ve Sonuçları Toplama” dersinde ne öğreneceğim?
İş parçacıklarını bekleyip çıktıyı toplayın. 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.
“Birleştirme ve Sonuçları Toplama” 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
- İş Parçacıkları Oluşturma
- Verileri İş Parçacıklarına Taşıma
- Arc ve Mutex ile Paylaşma
- Birleştirme ve Sonuçları Toplama