Learn Rust Coding · Ders

İş Parçacıklarıyla Korkusuz Eşzamanlılık

Veri yarışı olmamasını sağlayan iş parçacıkları ve ileti aktarımı dâhil olmak üzere Rust'ın eşzamanlı programlama temel yapılarını inceleyin.

İş Parçacıklarıyla Korkusuz Eşzamanlılık, CoddyKit'te ücretsiz bir Learn Rust Coding dersidir. Bu, 3 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 3 dersten oluşur.

Eşzamanlılığa Giriş

İş Parçacıklarıyla Korkusuz Eşzamanlılık dersine hoş geldiniz! Bu derste Rust programlarınızın aynı anda birden çok iş yapmasını nasıl sağlayacağınızı öğreneceksiniz.

Eşzamanlılık, birden çok hesaplamanın görünüşte aynı anda yürütülmesi anlamına gelir. Duyarlı uygulamalar ve modern çok çekirdekli işlemcilerden yararlanmak için hayati önem taşır.

İş parçacıkları, bir program içindeki hafif yürütme birimleridir.
Her iş parçacığı kodunuzun ayrı bir bölümünü çalıştırabilir.
Rust'ın sahiplik sistemi, yaygın eşzamanlılık hatalarını önlemeye yardımcı olur.

İlk İş Parçacığınızı Oluşturma

Rust, yeni iş parçacıkları oluşturmak için std::thread::spawn sağlar. Yeni iş parçacığının çalıştırması gereken kodu içeren bir closure (anonim işlev) geçirirsiniz.

İş parçacıklarının işleyişini görmek için bu örneği çalıştırmayı deneyin:

use std::thread;
use std::time::Duration;

fn main() {
  println!("Hello from the main thread!");

  thread::spawn(|| {
    for i in 1..=5 {
      println!("Hi number {} from the spawned thread!", i);
      thread::sleep(Duration::from_millis(1));
    }
  });

  for i in 1..=3 {
    println!("Hi number {} from the main thread!", i);
    thread::sleep(Duration::from_millis(1));
  }
}

`join` ile İş Parçacıklarını Bekleme

Önceki örnekte oluşturulan iş parçacığı, ana iş parçacığı sona ermeden önce tamamlanmayabilir. Bunun nedeni, ana iş parçacığının varsayılan olarak oluşturulan iş parçacıklarını beklememesidir.

Oluşturulan bir iş parçacığının işini tamamlamasını sağlamak için JoinHandle üzerindeki join() yöntemini kullanırız. Bu, birleştirilen iş parçacığı tamamlanana kadar geçerli iş parçacığını engeller.

use std::thread;
use std::time::Duration;

fn main() {
  let handle = thread::spawn(|| {
    for i in 1..=5 {
      println!("Thread: {}", i);
      thread::sleep(Duration::from_millis(1));
    }
  });

  for i in 1..=3 {
    println!("Main: {}", i);
    thread::sleep(Duration::from_millis(1));
  }

  handle.join().unwrap(); // Wait for the spawned thread to finish
  println!("Spawned thread has finished!");
}

Verileri İş Parçacıklarına Taşıma

Bir spawn closure'ı içinde ortamdan değişkenler kullandığınızda Rust'ın sahiplik kuralları devreye girer. Closure'lar varsayılan olarak değişkenleri ödünç almaya çalışır.

Oluşturulan iş parçacığı, değişkenin tanımlandığı ana iş parçacığının kapsamından daha uzun yaşarsa bu durum sarkan bir başvuruya yol açabilir. Bunu düzeltmek için closure parametrelerinin önüne move anahtar sözcüğünü ekleyin.

move, closure'ı yakaladığı değişkenlerin sahipliğini almaya zorlar.
Bu, verilerin yeni iş parçacığının tüm yaşam süresi boyunca geçerli olmasını sağlar.

use std::thread;

fn main() {
  let data = String::from("Hello from outer scope");

  let handle = thread::spawn(move || { // Use 'move' to take ownership of 'data'
    println!("Data in thread: {}", data);
  });

  handle.join().unwrap();
  // println!("Data after thread: {}", data); // This would cause a compile error!
  println!("Main thread finished.");
}

İleti Aktarımıyla İletişim Kurma

Rust'ta iş parçacıkları arasında doğrudan veri paylaşmak (paylaşılan durum) mümkün olsa da dikkatli eşzamanlama gerektirir (örneğin, diğer derslerde ele alınan Mutex ve Arc ile).

Eşzamanlılık için daha güvenli ve çoğu zaman daha basit bir yaklaşım mesaj aktarmadır. İş parçacıkları birbirlerine mesaj göndererek iletişim kurar ve paylaşılan belleğe doğrudan erişmekten kaçınır.

Bir iş parçacığı veri gönderir.
Başka bir iş parçacığı veriyi alır.
Rust'ın standart kitaplığı bunun için std::sync::mpsc sağlar.

`mpsc` Kanalını Kurma

std::sync::mpsc, Multiple Producer, Single Consumer ifadesinin kısaltmasıdır. Bu, birçok iş parçacığının mesaj gönderebileceği, ancak yalnızca bir iş parçacığının bu mesajları alabileceği anlamına gelir.

Bir kanal oluşturmak için mpsc::channel() çağrılır. Bu çağrı aşağıdakileri içeren bir demet döndürür:

Bir Gönderici (tx): Mesaj göndermek için kullanılır.
Bir Alıcı (rx): Mesaj almak için kullanılır.

Şimdi nasıl kanal oluşturulacağını ve basit bir mesaj gönderileceğini görelim.

use std::sync::mpsc;
use std::thread;

fn main() {
  // Create a new channel
  let (tx, rx) = mpsc::channel();

  thread::spawn(move || {
    let val = String::from("hi");
    tx.send(val).unwrap(); // Send the message
    // println!("val is {}", val); // Error: val moved to tx.send()
  });

  // Receive the message in the main thread
  let received = rx.recv().unwrap();
  println!("Got: {}", received);
}

Birden Çok Mesaj Gönderme

Aynı kanal üzerinden birden çok mesaj gönderebilirsiniz. Receiver, bunu yönetmek için şu yöntemlere sahiptir:

rx.recv(): Bir mesaj alınana kadar geçerli iş parçacığını bekletir. Bir Result döndürür.
rx.try_recv(): Bekletme yapmaz. Hemen bir Result döndürür; mesaj varsa mesajı, yoksa hata bilgisini içerir.
Ayrıca gönderen kanalı kapatana kadar mesajları almak için Receiver üzerinde doğrudan yineleme yapabilirsiniz.

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn main() {
  let (tx, rx) = mpsc::channel();

  thread::spawn(move || {
    let msgs = vec!["hi", "from", "the", "thread"];
    for msg in msgs {
      tx.send(String::from(msg)).unwrap();
      thread::sleep(Duration::from_millis(10));
    }
  });

  // Iterate over the receiver to get all messages
  for received in rx {
    println!("Got: {}", received);
  }
  println!("All messages received!");
}

Birden Çok Gönderici, Tek Alıcı

mpsc içindeki 'MP', Multiple Producers ifadesinin kısaltmasıdır. Bir Sender öğesini çoğaltarak birden çok iş parçacığının aynı Receiver öğesine mesaj göndermesini sağlayabilirsiniz.

Çoğaltılan her Sender, aynı kanala erişimi paylaşır ve farklı iş parçacıklarından eşzamanlı mesaj gönderilmesine olanak tanır.

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn main() {
  let (tx, rx) = mpsc::channel();

  let tx1 = tx.clone(); // Clone the sender for another thread
  thread::spawn(move || {
    tx1.send(String::from("hello from tx1")).unwrap();
  });

  thread::spawn(move || {
    tx.send(String::from("hello from tx2")).unwrap();
  });

  // Collect all messages
  let mut received_messages: Vec<String> = vec![];
  for received in rx {
    received_messages.push(received);
    if received_messages.len() == 2 { break; } // Assuming 2 messages for this example
  }
  println!("Received: {:?}", received_messages);
}

Rust ile Endişesiz Eşzamanlılık

Rust'ın sahiplik ve tür sistemi, endişesiz eşzamanlılık elde etmek için çok önemlidir. Rust, kuralları derleme zamanında zorunlu kılarak veri yarışları gibi yaygın eşzamanlılık hatalarını önler.

Sahiplik, aynı veriye birden çok değiştirilebilir başvuruyu önler.
move anahtar sözcüğü, verilerin yeni bir iş parçacığına güvenli biçimde aktarılmasını sağlar.
Mesaj aktarma (mpsc), paylaşılan belleği tamamen ortadan kaldırarak iletişimi tasarım gereği güvenli hâle getirir.

Bu mekanizmalar, derleyicinin olası sorunların çoğunu yakalayacağını bilerek eşzamanlı kodu güvenle yazmanıza olanak tanır.

Eşzamanlılık Kavramları Kontrolü

Rust'ın eşzamanlılık ilkelleri hakkındaki aşağıdaki ifadelerden hangileri doğrudur?

Tekrar: İş Parçacıkları ve Mesaj Aktarma

Harika iş çıkardınız! Rust'ta endişesiz eşzamanlılığın temellerini öğrendiniz:

std::thread::spawn kullanarak yeni iş parçacıkları oluştururuz.
Bir iş parçacığının tamamlanmasını beklemek için JoinHandle::join() kullanırız.
move anahtar sözcüğü, verilerin sahipliğini güvenli biçimde bir iş parçacığına aktarır.
std::sync::mpsc, iş parçacıkları arası iletişim için güçlü bir mesaj aktarma sistemi sağlar.
Rust'ın sahiplik kuralları veri yarışlarını derleme zamanında önleyerek eşzamanlı programlamayı daha güvenli hâle getirir.

Bu ders, duyarlı ve verimli uygulamalar oluşturmanız için sağlam bir temel sağlar. Pratik yapmaya devam edin!

Sıkça Sorulan Sorular

“İş Parçacıklarıyla Korkusuz Eşzamanlılık” dersi ücretsiz mi?

Evet — “İş Parçacıklarıyla Korkusuz Eşzamanlılık” 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 3 dersten oluşur.

“İş Parçacıklarıyla Korkusuz Eşzamanlılık” dersinde ne öğreneceğim?

Veri yarışı olmamasını sağlayan iş parçacıkları ve ileti aktarımı dâhil olmak üzere Rust'ın eşzamanlı programlama temel yapılarını inceleyin. 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, 3 dersinin 3. dersidir.

“İş Parçacıklarıyla Korkusuz Eşzamanlılık” 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

Box, Rc ve Arc Akıllı İşaretçileri
İç Değiştirilebilirlik: RefCell, Cell
İş Parçacıklarıyla Korkusuz Eşzamanlılık

← Learn Rust Coding Sayfasına Dön