0Pricing
Learn Rust Coding · Ders

Future'lar ve Görevlerle Çalışma

`Future` özelliğini ve görevlerin eşzamansız bir çalışma zamanı ortamında nasıl planlanıp yönetildiğini anlayın.

Future'lar ve Görevlerle Çalışma, 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.

Rust Future Nedir?

Eşzamansız Rust'ta Future, bir noktada tamamlanabilecek eşzamansız bir hesaplamayı temsil eden bir özelliktir. Bunu, henüz hazır olmayan bir değer için verilen söz gibi düşünebilirsiniz.

  • Eşzamansız Rust'ın temel yapı taşıdır.
  • Rust'taki async fn işlevleri aslında Future özelliğini uygulayan anonim bir tür döndürür.
  • Değer hemen hesaplanmaz; bir yürütücü tarafından "yoklandığında" hesaplanır.

Future'lar Nasıl İlerler

Bir Future kendi başına çalışmaz. Bir yürütücü (Tokio çalışma zamanı gibi), ilerleme kaydedip kaydetmediğini veya tamamlanıp tamamlanmadığını kontrol etmek için onu tekrar tekrar "yoklar".

  • Yoklandığında bir Future, Poll::Pending (henüz tamamlanmadı) veya Poll::Ready(T) (tamamlandı, sonuç burada) döndürür.
  • Pending durumunda yürütücü, ilgili bir olay gerçekleştiğinde (örneğin G/Ç işlemi tamamlandığında) onu daha sonra yeniden yoklaması gerektiğini bilir.
  • Bu yoklama mekanizması, birçok eşzamansız işlemin tek bir iş parçacığında eşzamanlı olarak çalışmasını sağlar.

Eşzamansız Kodunuz Bir Future'dır

Bir async fn yazdığınızda Rust, onu Future özelliğini uygulayan bir durum makinesine dönüştürür. Gerçek hesaplama, yalnızca döndürülen Future yoklandığında başlar.

Basit bir async işlev görelim. Bir yürütücü tarafından beklenene kadar çalışmaz.

async fn say_hello() -> String {
    "Hello from a Future!".to_string()
}

#[tokio::main]
async fn main() {
    let future = say_hello(); // This doesn't run the function yet!
    println!("Future created, but not awaited.");
    // To run it, an executor needs to poll it, often via .await
    // let result = future.await;
    // println!("{}", result);
}

Future'lar Görevlere Dönüşür

Bir Future eşzamansız bir hesaplamanın tanımıyken, bir görev yürütücü tarafından tamamlanmaya yönlendirilen bu Future'ın etkin bir örneğidir.

  • Bir yürütücüye (Tokio gibi) bir Future çalıştırmasını söylediğinizde, onu bir görevin içine sarar.
  • Yürütücü daha sonra bu görevi yönetir ve ilerlemeye hazır olduğunda onu yoklar.
  • Görevler, eşzamansız çalışma zamanının zamanlayıp eşzamanlı olarak yürüttüğü iş birimleridir.

Eşzamanlılık İçin Görevleri Başlatma

Bir Future'ı başka kodlarla eşzamanlı olarak çalıştırmak için onu Tokio çalışma zamanına "başlatırsınız". Böylece çalışma zamanının yöneteceği yeni bir görev oluşturulur.

tokio::spawn işlevi bir Future alır ve görevin tamamlanmasını beklemek ve sonucunu almak için kullanabileceğiniz bir JoinHandle döndürür.

async fn perform_task(id: u8) -> String {
    tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
    format!("Task {} finished!", id)
}

#[tokio::main]
async fn main() {
    println!("Main started.");
    let handle = tokio::spawn(async {
        perform_task(1).await
    });
    println!("Task 1 spawned.");
    // We will await 'handle' in the next scene to get the result.
    // let result = handle.await.unwrap();
    // println!("{}", result);
}

Görevlerden Sonuçları Alma

tokio::spawn tarafından döndürülen JoinHandle kendisi de bir Future'dır. Oluşturulan görevin tamamlanmasını beklemek ve dönüş değerini almak için bu tanıtıcı üzerinde .await kullanabilirsiniz.

Oluşturulan görev panik yaparsa, JoinHandle üzerinde bekleme işlemi bir hata döndürür.

async fn perform_task(id: u8) -> String {
    tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
    format!("Task {} finished!", id)
}

#[tokio::main]
async fn main() {
    println!("Main started.");
    let handle = tokio::spawn(async {
        perform_task(1).await
    });
    println!("Task 1 spawned.");
    let result = handle.await.unwrap(); // Await the handle to get the result
    println!("{}", result);
    println!("Main finished.");
}

Birden Çok Eşzamanlı Görev

Görevlerin ve tokio::spawn işlevinin gücü, birden çok işlemi eşzamanlı olarak çalıştırdığınızda gerçekten ortaya çıkar. Tokio çalışma zamanı, görevler ilerlemeye hazır hâle geldikçe aralarında verimli bir şekilde geçiş yapar.

Bu sayede programınız, tek bir iş parçacığında bile engellenmeden aynı anda birçok işte ilerleme kaydedebilir.

async fn long_task(id: u8) -> String {
    tokio::time::sleep(tokio::time::Duration::from_millis(100 + id as u64 * 50)).await;
    format!("Long task {} done!", id)
}

#[tokio::main]
async fn main() {
    println!("Main started.");
    let handle1 = tokio::spawn(long_task(1));
    let handle2 = tokio::spawn(long_task(2));
    println!("Both tasks spawned.");
    let result1 = handle1.await.unwrap();
    let result2 = handle2.await.unwrap();
    println!("{}\n{}", result1, result2);
    println!("Main finished.");
}

join! ile Tümünü Bekleme

Birden çok Future'ın aynı anda tamamlanmasını beklemeniz gerektiğinde tokio::join! yararlı bir makrodur. Verilen tüm gelecekleri eşzamanlı olarak bekler ve sonuçlarını bir demet olarak döndürür.

Her tanıtıcıyı ayrı ayrı beklemeye benzer, ancak sabit sayıda gelecek için genellikle daha özlüdür.

async fn fetch_data(source: &str) -> String {
    tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
    format!("Data from {}", source)
}

#[tokio::main]
async fn main() {
    println!("Starting data fetches...");
    let (data_a, data_b) = tokio::join!(
        fetch_data("Server A"),
        fetch_data("Database B")
    );
    println!("Fetched: {}\nFetched: {}", data_a, data_b);
    println!("All fetches complete.");
}

Görev Hatalarını Ele Alma

Eşzamansız işlemler de eşzamanlı işlemler gibi başarısız olabilir. Future'ların başarıyı veya başarısızlığı belirten bir Result türü döndürmesi yaygındır.

Bir JoinHandle üzerinde bekleme yaparken sonucun, görevin kendisi panik yapabileceği için başka bir Result içine sarıldığını unutmayın. Sıkça handle.await? (bir Result döndüren async fn içindeyseniz) veya handle.await.unwrap() / .expect() görürsünüz.

async fn might_fail(should_fail: bool) -> Result<String, &'static str> {
    tokio::time::sleep(tokio::time::Duration::from_millis(30)).await;
    if should_fail {
        Err("Oops, something went wrong!")
    } else {
        Ok("Operation successful!".to_string())
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let handle_ok = tokio::spawn(might_fail(false));
    let handle_err = tokio::spawn(might_fail(true));

    let result_ok = handle_ok.await??; // Await handle, then await inner Result
    println!("{}", result_ok);

    match handle_err.await? { // Await handle, then handle inner Result
        Ok(val) => println!("{}", val),
        Err(e) => eprintln!("Error: {}", e),
    }
    Ok(())
}

Future'ları ve Görevleri Anlama

Future'ları hesaplamalar, görevleri ise bunların yürütülen örnekleri olarak öğrendiniz. tokio::spawn ve JoinHandle hakkında aşağıdaki ifadelerden hangisi doğrudur?

Özet: Future'lar ve Görevler

Harika iş! Artık Rust'ın eşzamansız ekosistemindeki Future'ların ve görevlerin temel kavramlarını kavradınız:

  • Bir Future, sonunda bir değer üretecek eşzamansız bir hesaplamayı temsil eden özelliktir.
  • async fn işlevleri, Future özelliğini uygulayan türlere derlenir.
  • Görev, bir yürütücünün (Tokio gibi) etkin olarak yönettiği ve yokladığı bir Future örneğidir.
  • tokio::spawn, yeni bir görev oluşturmak için kullanılır ve bir JoinHandle döndürür.
  • Oluşturulan görevin sonucunu almak için bir JoinHandle üzerinde .await kullanırsınız.

Bu yapı taşları, verimli ve engelleyici olmayan Rust uygulamaları yazmak için gereklidir!

Sıkça Sorulan Sorular

“Future'lar ve Görevlerle Çalışma” dersi ücretsiz mi?

Evet — “Future'lar ve Görevlerle Çalış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 3 dersten oluşur.

“Future'lar ve Görevlerle Çalışma” dersinde ne öğreneceğim?

`Future` özelliğini ve görevlerin eşzamansız bir çalışma zamanı ortamında nasıl planlanıp yönetildiğini anlayı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, 3 dersinin 3. dersidir.

“Future'lar ve Görevlerle Çalış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

  1. Async/Await'e Giriş
  2. Tokio ile Eşzamansız Uygulamalar Geliştirme
  3. Future'lar ve Görevlerle Çalışma
← Learn Rust Coding Sayfasına Dön