Rust'ın Korkusuz Eş Zamanlılığı İçin Bir Kılavuz

Eşzamanlılık, bir programın aynı CPU çekirdeğinde aynı anda birden çok görevi yürütme yeteneğidir. Eşzamanlı görevler, paralellikten farklı olarak, belirli bir sıra olmadan çakışan zamanda çalışır ve tamamlanır. aynı görevin çeşitli görevlerinin veya alt görevlerinin birden çok donanımda aynı anda çalıştığı yer işlemciler.

Rust, performans özellikleri ve güvenli, verimli bir şekilde eşzamanlılık desteği ile öne çıkıyor. Rust'ın eşzamanlılık yaklaşımı, dilin güvenli yazmayı kolaylaştırmayı amaçladığı "korkusuz eşzamanlılık" kavramına dayanmaktadır. veri izlerini önlemek ve belleği sağlamak için derleme zamanında katı kurallar uygulayan sahiplik ve ödünç alma sistemi aracılığıyla eşzamanlı kod emniyet.

Rust'ta Eş Zamanlılığı Anlamak

Rust, eşzamansız programlama için iş parçacığı, ileti geçirme, muteksler, atomik türler ve eşzamansız programlama için eşzamansız/bekliyor dahil olmak üzere eş zamanlı programlar yazmak için çeşitli eşzamanlılık ilkelleri sağlar.

İşte Rust'un eşzamanlılık ilkelerine genel bir bakış:

1. İş Parçacığı: Pas sağlar std:: iş parçacığı Konu oluşturmak ve yönetmek için standart kitaplığındaki modül. ile yeni konular oluşturabilirsiniz. Konu:: doğmak işlev. bu Konu:: doğmak yürütme kodunu içeren bir kapanış alır. Paralel olarak çalışabilen iş parçacıkları da çalıştırabilirsiniz ve Rust, bunların yürütülmesini koordine etmek için senkronizasyon ilkelleri sağlar. Ödünç denetleyici referansların beklenmeyen davranışlara yol açmamasını sağlar.
2. İleti geçişi: Rust'ın eşzamanlılık modeli, ileti dizileri arasında ileti geçişini destekler. aracılığıyla uygulanan kanalları kullanacaksınız. std:: senkronizasyon:: mpsc mesaj geçiş modülü. Bir kanal bir vericiden oluşur (Gönderen) ve bir alıcı (Alıcı). Konular, verici aracılığıyla mesaj gönderebilir ve alıcı aracılığıyla alabilir. Bu, iş parçacıkları arasında güvenli ve senkronize bir iletişim yolu sağlar.
3. Muteksler ve Atom Türleri: Rust, muteksler (std:: senkronizasyon:: Mutex) ve atomik tipler (std:: senkronizasyon:: atomik), özel veri paylaşımı erişimi sağlamak için. Mutex'ler, veri yarışlarını önlerken birden çok iş parçacığının aynı anda verilere erişmesine izin verir. Atom türleri, açık kilitleme gerektirmeden, paylaşılan veriler üzerinde bir sayacı artırma gibi atomik işlemler sağlar.
4. Eşzamansız/Bekliyor ve Vadeli İşlemler: Rust'ın zaman uyumsuz/beklemek sözdizimi, eşzamanlı olarak yürütebileceğiniz eşzamansız kod yazmak için işlevsellik sağlar. Eşzamansız programlar, programların diğer G/Ç işlemlerini beklerken diğer görevleri gerçekleştirmesini sağlayan G/Ç'ye bağlı görevlerle verimli bir şekilde ilgilenir. Rust'ın zaman uyumsuz/beklemek sözdizimi vadeli işlemlere dayalıdır ve bunları async-std veya tokio çalışma zamanı kitaplıkları.

Rust iş parçacıkları hafiftir ve çalışma zamanı ek yükünün olmaması, onları yüksek performanslı uygulamalar için çok uygun hale getirir. Rust'ın eşzamanlılık ilkeleri, farklı eşzamanlılık ihtiyaçları için birden çok kitaplık ve çerçeveyle sorunsuz bir şekilde entegre olur.

Rust'ta Spawn Konuları Nasıl Kullanılır

kullanacaksın std:: iş parçacığı konuları oluşturmak için modül. bu std:: iş parçacığı:: yumurtlama işlevi, ana iş parçacığı veya programınızdaki diğer mevcut iş parçacıkları ile aynı anda çalışacak yeni bir iş parçacığı oluşturmanıza olanak tanır.

İle bir iş parçacığını şu şekilde oluşturabilirsiniz: std:: iş parçacığı:: yumurtlama işlev:

kullanmak std:: iş parçacığı;
fnana() {
// Yeni bir iş parçacığı oluştur
izin vermek thread_handle = thread:: spawn(|| {
// Yeni iş parçacığında yürütülen kod buraya gelir
yazdır!("Yeni başlıktan merhaba!");
 });
// Oluşturulan iş parçacığının bitmesini bekleyin
 thread_handle.join().unwrap();
// Ana iş parçacığında yürütülen kod burada devam eder
yazdır!("Ana başlıktan merhaba!");
}

bu ana işlevi ile yeni bir iş parçacığı oluşturur Konu:: doğmak iş parçacığında yürütme kodunu içeren bir kapatma geçirerek işlev (bu durumda, kapatma anonim bir işlevdir). Kapatma, yeni iş parçacığının çalıştığını belirten bir mesaj yazdırır.

bu katılmak yöntemi thread_handle ana iş parçacığının, oluşturulan iş parçacığının yürütmeyi tamamlamasını beklemesine izin verir. Arayarak katılmakişlev, ana iş parçacığının devam etmeden önce oluşturulan iş parçacığının tamamlanmasını beklemesini sağlar.

Birden fazla iş parçacığı oluşturabilir ve bir döngü veya başka herhangi bir şey kullanabilirsiniz. Pas kontrol yapısı birden çok kapanış oluşturmak ve her biri için iş parçacığı oluşturmak.

kullanmak std:: iş parçacığı;
fnana() {
izin vermek sayı_threads = 5;
izin vermekmut thread_handles = vec![];
için Ben içinde0..num_threads {
izin vermek thread_handle = thread:: yumurtlama(taşınmak || {
yazdır!("{} ileti dizisinden merhaba", Ben);
 });
 thread_handles.push (thread_handle);
 }
için halletmek içinde thread_handles {
 handle.join().unwrap();
 }
yazdır!("Tüm ileti dizileri tamamlandı!");
}

For döngüsü, her biri benzersiz bir tanımlayıcıya atanan beş iş parçacığı oluşturur. Ben döngü değişkeni ile. Kapaklar değerini yakalar Ben ile taşınmak kaçınılması gereken anahtar kelime mülkiyet sorunları, ve thread_handles vektör, konuları daha sonrası için depolar katılmak döngü.

Tüm iş parçacıklarını oluşturduktan sonra, ana işlev üzerinde yinelenir thread_handles vektör, aramalar katılmak her tanıtıcıda bulunur ve tüm iş parçacıklarının yürütülmesini bekler.

Mesajları Kanallardan Geçirmek

İletileri kanallarla ileti dizilerinden iletebilirsiniz. Rust, mesaj iletimi için işlevsellik sağlar. std:: senkronizasyon:: mpsc modül. Burada, mpsc "çoklu üretici, tek tüketici" anlamına gelir ve kanallar aracılığıyla mesaj gönderip alarak birden çok iş parçacığı arasında iletişime izin verir.

Programlarınızda evreler arası iletişim kanallarından ileti geçişini şu şekilde uygulayabilirsiniz:

kullanmak std:: senkronizasyon:: mpsc;
kullanmak std:: iş parçacığı;
fnana() {
// bir kanal oluştur
izin vermek (gönderen, alıcı) = mpsc:: kanal();
// Bir iş parçacığı oluştur
 Konu:: spawn(taşınmak || {
// Kanal üzerinden bir mesaj gönder
 gönderen.gönder("İplikten merhaba!").aç();
 });
// Ana başlıktaki mesajı al
izin vermek alınan_mesaj = alıcı.recv().unwrap();
yazdır!("Alınan mesaj: {}", alınan_mesaj);
}

bu ana işlevi ile bir kanal oluşturur mpsc:: kanal() bu bir döndürür gönderen ve bir alıcı. bu gönderen şuraya mesajlar gönderir: alıcı ki mesajları alır. bu ana işlev, ileti dizileri oluşturmaya ve sahipliğini taşımaya devam eder. Gönderen iplik kapatma için. İplik kapatmanın içinde, gönderen.gönder() kanal üzerinden bir mesaj gönderir.

bu alıcı.recv() işlev, iletiyi, iş parçacığı iletiyi alana kadar yürütmeyi durdurarak alır. bu ana işlevi, başarılı bir mesaj alımından sonra mesajı konsola yazdırır.

Kanal aracılığıyla mesaj göndermenin göndereni tükettiğini unutmayın. Birden fazla diziden mesaj göndermeniz gerekiyorsa, göndereni gönderen.klon() işlev.

Ek olarak, mpsc modül gibi başka yöntemler sağlar try_recv(), engellenmeyen bir mesaj almaya çalışır ve iter(), alınan mesajlar üzerinde bir yineleyici oluşturur.

Kanallar aracılığıyla ileti aktarımı, veri yarışlarından kaçınırken ve uygun senkronizasyonu sağlarken iş parçacıkları arasında iletişim kurmanın güvenli ve uygun bir yolunu sağlar.

Rust'ın Sahiplik ve Ödünç Alma Modeli Bellek Güvenliğini Garanti Ediyor

Rust, sağlam, güvenli, eşzamanlı bir programlama çerçevesi sağlamak için sahiplik, ödünç alma ve ödünç alma denetleyicisini birleştirir.

Ödünç alma denetleyicisi, çalışma zamanı denetimlerine veya çöp toplamaya güvenmek yerine olası sorunları derleme zamanında tespit ederek bir güvenlik ağı görevi görür.