Arc ve Mutex ile Paylaşma
Paylaşılan durumu güvenle değiştirin.
Arc ve Mutex ile Paylaşma, CoddyKit'te ücretsiz bir Learn Rust Coding dersidir. Bu, 4 dersinin 3. 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.
Paylaşılan Durum Gereksinimi
Bazen birkaç iş parçacığının aynı veriyi okuması veya güncellemesi gerekir. Sahipliği tek bir iş parçacığına taşımak yeterli değildir.
Rust, Arc ile iş parçacıkları arasında güvenli paylaşılan sahiplik, Mutex ile de güvenli değişiklik yapma olanağı sunar. Birlikte, paylaşılan ve değiştirilebilir durumu mümkün kılarlar.
Arc: Atomik Başvuru Sayımı
Arc, atomik olarak başvuru sayımı yapılan anlamına gelir. Rc gibidir; ancak sayacı atomik işlemler kullandığından iş parçacıkları arasında güvenlidir.
Bir Arc değerini kopyalamak verileri kopyalamaz. Yalnızca sayacı artırır ve aynı değere işaret eden başka bir tutamaç döndürür.
use std::sync::Arc;
fn main() {
let shared = Arc::new(vec![1, 2, 3]);
let clone = Arc::clone(&shared);
println!("{:?} {:?}", shared, clone);
}Arc'ı İş Parçacıkları Arasında Paylaşmak
Salt okunur verileri paylaşmak için Arc değerini her iş parçacığı için bir kez kopyalayın ve her kopyayı içeri taşıyın. Tüm iş parçacıkları aynı bellek tahsisine işaret eder.
Arc hem Send hem de Sync olduğundan bu kod sorunsuz derlenir.
use std::sync::Arc;
use std::thread;
fn main() {
let data = Arc::new(vec![10, 20, 30]);
let mut handles = vec![];
for i in 0..3 {
let d = Arc::clone(&data);
handles.push(thread::spawn(move || println!("{}", d[i])));
}
for h in handles { h.join().unwrap(); }
}Arc Tek Başına Salt Okunurdur
Arc size paylaşılan sahiplik verir; ancak iç değere yalnızca paylaşılan, değiştirilemez erişim sağlar.
Birden çok iş parçacığı aynı anda Arc değerini tuttuğunda yarış durumu oluşabileceği için verileri doğrudan bir Arc üzerinden değiştiremezsiniz. Kilit ile iç değişebilirlik kullanmanız gerekir.
Mutex: Karşılıklı Dışlama
Bir Mutex, verilere aynı anda yalnızca bir iş parçacığının erişebilmesi için onları korur. Erişim elde etmek için lock çağrısı yaparsınız.
lock bir Result döndürür; açma işlemi akıllı işaretçi koruyucusu verir. Diğer iş parçacıkları koruyucu bırakılana kadar bekler.
use std::sync::Mutex;
fn main() {
let m = Mutex::new(0);
{
let mut guard = m.lock().unwrap();
*guard += 5;
}
println!("{:?}", m);
}Koruyucu ve RAII
lock tarafından döndürülen değer bir MutexGuard'dır. İç verilere * ile başvurusunu kaldırarak erişirsiniz.
Koruyucu kapsam dışına çıktığında kilit otomatik olarak serbest bırakılır. Bu RAII yaklaşımı kilidi açmayı unutmanızı önler.
Arc ve Mutex'i Birleştirmek
Değiştirilebilir durumu iş parçacıkları arasında paylaşmak için bir Mutex değerini Arc içine sarın. Arc sahipliği paylaşır; Mutex değişiklikleri korur.
Arc<Mutex<T>> biçimindeki bu yaklaşım, Rust'ta paylaşılan ve değiştirilebilir durum için standart yöntemdir.
use std::sync::{Arc, Mutex};
fn main() {
let counter = Arc::new(Mutex::new(0));
let c = Arc::clone(&counter);
*c.lock().unwrap() += 1;
println!("{}", *counter.lock().unwrap());
}Paylaşılan Bir Sayaç
Burada on iş parçacığının her biri paylaşılan bir sayacı bir artırır. Her biri Arc değerini kopyalar, Mutex kilidini alır ve bir ekler.
Kilit erişimi sıraya koyduğu için son toplam her zaman tam olarak on olur.
use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];
for _ in 0..10 {
let c = Arc::clone(&counter);
handles.push(thread::spawn(move || {
*c.lock().unwrap() += 1;
}));
}
for h in handles { h.join().unwrap(); }
println!("{}", *counter.lock().unwrap());
}Kritik Bölümleri Kısa Tutun
Kilit tutulurken yürütülen kod kritik bölümdür. Diğer iş parçacıkları burada beklediğinden bu bölümü kısa tutun.
Kilidi alın, en az gerekli güncellemeyi yapın ve ardından serbest bırakın. Kilit tutulurken yoğun hesaplama veya G/Ç yapmaktan kaçının.
use std::sync::Mutex;
fn main() {
let m = Mutex::new(Vec::new());
{
let mut v = m.lock().unwrap();
v.push(1);
} // lock released here
println!("{:?}", m.lock().unwrap());
}Kilitlenmeler ve Zehirlenme
Bir iş parçacığı aynı Mutex değerini iki kez kilitlerse veya iki iş parçacığı iki mutex'i zıt sırayla kilitlerse kilitlenme yaşanabilir ve program sonsuza kadar takılabilir.
Bir iş parçacığı kilit tutarken paniğe kapılırsa Mutex zehirlenmiş olur ve sonraki lock çağrıları bir Err döndürür.
Çok Sayıda Okuyucu İçin RwLock
Okuma işlemleri yazma işlemlerinden çok daha fazlaysa RwLock, Mutex'ten daha iyi olabilir. Aynı anda birçok okuyucuya veya tek bir özel yazıcıya izin verir.
Paylaşılan erişim için read, özel erişim için write kullanın.
use std::sync::RwLock;
fn main() {
let lock = RwLock::new(5);
{
let r = lock.read().unwrap();
println!("read {}", *r);
}
*lock.write().unwrap() += 1;
println!("{}", *lock.read().unwrap());
}Hızlı Kontrol
Arc ve Mutex konusundaki anlayışınızı sınayın.
Özet
Arc'ın atomik başvuru sayımıyla sahipliği iş parçacıkları arasında paylaştığını, ancak yalnızca değiştirilemez erişime izin verdiğini öğrendiniz.
Bir Mutex değişiklikleri korur ve bırakıldığında kilidi serbest bırakan bir koruyucu verir. Paylaşılan ve değiştirilebilir durum için bunları Arc<Mutex<T>> olarak birleştirin; kilitlenmelere ve zehirlenmeye dikkat edin.
Sonraki derste iş parçacıklarına katılacak ve sonuçlarını toplayacaksınız.
Sıkça Sorulan Sorular
“Arc ve Mutex ile Paylaşma” dersi ücretsiz mi?
Evet — “Arc ve Mutex ile Paylaşma” 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.
“Arc ve Mutex ile Paylaşma” dersinde ne öğreneceğim?
Paylaşılan durumu güvenle değiştirin. 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 3. dersidir.
“Arc ve Mutex ile Paylaşma” 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