PricingLoginStart free
Learn Rust Coding · Ders

Tokio ile Eşzamansız Uygulamalar Geliştirme

G/Ç ve diğer eşzamanlı işlemleri yöneterek eşzamansız görevleri verimli biçimde yürütmek için Tokio çalışma zamanını kullanın.

2. ders / 311 adım

Tokio ile Eşzamansız Uygulamalar Geliştirme, CoddyKit'te ücretsiz bir Learn Rust Coding dersidir. Bu, 3 dersinin 2. 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.

Tokio Çalışma Zamanıyla Tanışın

Tekrar hoş geldiniz! Önceki derste async ve await hakkında bilgi edindiniz. Peki bir async işlevi gerçekte nasıl çalışır?

Tokio gibi bir eşzamansız çalışma zamanı burada devreye girer. Tokio, eşzamansız Rust kodunuz için yürütme ortamı sağlayan güçlü bir kitaplıktır.

  • Future'ları planlar ve yürütür.
  • Beklemesiz G/Ç işlemlerini yönetir.
  • Eşzamanlı görevleri verimli biçimde yönetir.

Eşzamansız Kodunuzu Çalıştırma

Tokio'yu kullanmaya başlamak için genellikle #[tokio::main] öznitelik makrosunu kullanırsınız. Bu makro, async fn main() işlevinizi Tokio çalışma zamanını başlatan ve eşzamansız kodunuzu çalıştıran standart bir fn main() işlevine dönüştürür.

Bunu eşzamansız uygulamanızın giriş noktası olarak düşünebilirsiniz.

use tokio;

#[tokio::main]
async fn main() {
  println!("Hello from Tokio!");
}

Yeni Eşzamansız Görevler Başlatma

Tokio'nun temel özelliklerinden biri, birden çok eşzamansız işlemi eşzamanlı çalıştırabilmesidir. Bunu tokio::spawn kullanarak gerçekleştirebilirsiniz.

tokio::spawn, bir Future alır ve çalıştırılmak üzere Tokio çalışma zamanına planlar. Böylece başlatılan görev arka planda çalışırken ana göreviniz yürütülmeye devam edebilir.

  • Bekletme yapmaz.
  • Tamamlanmasını beklemek için bir JoinHandle döndürür.
  • Görevler bağımsız olarak çalışır.

<code>tokio::spawn</code> İş Başında

tokio::spawn'un kodu eşzamanlı çalıştırmanızı nasıl sağladığını görelim. Her iki mesajın da göründüğüne, ancak uyku nedeniyle 'tamamlandı' mesajının 'görev tamamlandı' mesajından önce yazdırılabileceğine dikkat edin.

use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
  // Spawn a new task
  let handle = tokio::spawn(async {
    sleep(Duration::from_secs(1)).await;
    println!("Async task complete!");
  });

  println!("Main task continuing...");

  // Wait for the spawned task to finish
  handle.await.unwrap();
  println!("All tasks done.");
}

Birden Çok Görevi Bekleme

Birden çok göreviniz olduğunda çoğu zaman hepsinin tamamlanmasını beklemeniz gerekir. Tokio bu amaçla tokio::join! makrosunu sağlar.

tokio::join!, birden çok Future'ın eşzamanlı olarak beklenmesine ve sonuçlarının birleştirilmesine olanak tanır. Birden çok JoinHandle üzerinde `await` kullanmaya benzer, ancak sabit sayıdaki Future için çoğu zaman daha kısa bir yazım sunar.

use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
  let task1 = async {
    sleep(Duration::from_secs(1)).await;
    println!("Task 1 finished");
    1
  };

  let task2 = async {
    sleep(Duration::from_millis(500)).await;
    println!("Task 2 finished");
    2
  };

  let (result1, result2) = tokio::join!(task1, task2);
  println!("Results: {}, {}", result1, result2);
}

Tokio ile Eşzamansız Dosya G/Ç'si

Geleneksel dosya işlemleri iş parçacığını bekletebilir; bu da eşzamansız uygulamalar için kötüdür. Tokio'nun tokio::fs modülü, dosya sistemi işlemlerinin eşzamansız sürümlerini sağlar.

Bu sayede G/Ç işlemleri beklemesiz biçimde yürütüldüğü için uygulamanız büyük dosyaları okurken veya çok sayıda dosya işlemi gerçekleştirirken bile yanıt vermeye devam eder.

  • tokio::fs::read_to_string
  • tokio::fs::write
  • Daha fazla denetim için tokio::fs::File

Bir Dosyayı Eşzamansız Okuma

tokio::fs::read_to_string kullanarak bir dosyayı eşzamansız biçimde nasıl okuyabileceğiniz aşağıda gösterilmiştir. Bu kodun çalışması için Rust projenizle aynı dizinde (örneğin src/ içinde veya projenin kök dizininde) hello.txt adlı ve içinde bir miktar içerik bulunan bir dosya olduğundan emin olun.

use tokio::fs;

#[tokio::main]
async fn main() {
  let path = "hello.txt";
  // Create a dummy file for the example if it doesn't exist
  // In a real app, you'd handle file creation/existence more robustly
  if let Err(_) = fs::metadata(path).await {
    fs::write(path, "Hello, Tokio file!").await.unwrap();
  }

  match fs::read_to_string(path).await {
    Ok(content) => println!("File content: '{}'", content),
    Err(e) => eprintln!("Error reading file: {}", e),
  }
}

Eşzamansız Ağ İşlemleri

Tokio, ağ programlamada gerçekten öne çıkar. tokio::net modülü, TCP ve UDP iletişimi için beklemesiz ilkeller sunar.

Bu, her bağlantı için ayrı bir iş parçacığı gerektirmeden aynı anda çok sayıda bağlantıyı yönetebilen yüksek performanslı sunucular veya istemciler oluşturmak için kritik öneme sahiptir.

  • Sunucular için tokio::net::TcpListener.
  • İstemci bağlantıları için tokio::net::TcpStream.

Temel Eşzamansız TCP Sunucusu Yapısı

Tam kapsamlı bir sunucu karmaşık olsa da bu kod parçası, Tokio kullanan eşzamansız bir TCP sunucusunun temel döngüsünü gösterir. Gelen bağlantıları dinler ve her biri için bir mesaj yazdırır. Bunu çalıştırmayı deneyin, ardından bağlantıları görmek için tarayıcınızda http://127.0.0.1:8080 adresini açın.

use tokio::net::TcpListener;

#[tokio::main]
async fn main() {
  let listener = TcpListener::bind("127.0.0.1:8080").await.unwrap();
  println!("Listening on: {}", listener.local_addr().unwrap());

  loop {
    let (socket, addr) = listener.accept().await.unwrap();
    println!("Accepted connection from: {}", addr);
    // In a real server, you'd spawn a task to handle the socket
    // tokio::spawn(async move { handle_connection(socket).await; });
  }
}

// fn handle_connection(socket: TcpStream) { /* ... */ } // Placeholder

Tokio Görevi Mücadelesi

Tokio kullanan aşağıdaki Rust kodunu inceleyin. Bu program çalıştığında konsola yazdırılan *ilk* mesaj ne olacaktır?

use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
  tokio::spawn(async {
    sleep(Duration::from_millis(200)).await;
    println!("Task 1: Done");
  });

  tokio::spawn(async {
    sleep(Duration::from_millis(100)).await;
    println!("Task 2: Done");
  });

  println!("Main: Starting tasks...");

  sleep(Duration::from_millis(300)).await;
  println!("Main: Finishing.");
}
İnteraktif derste cevapla

Tekrar: Tokio ile Geliştirme

Rust ve Tokio ile eşzamansız uygulamalar geliştirme yolunda önemli bir adım attınız!

  • Tokio, eşzamansız çalışma zamanı olarak görev yapar ve async kodunuzu yürütür.
  • #[tokio::main], programınızın eşzamansız başlangıç noktasıdır.
  • tokio::spawn, birden çok görevi eşzamanlı olarak çalıştırmanızı sağlar.
  • tokio::join!, birden çok geleceği beklemenize yardımcı olur.
  • Tokio, dosyalar (tokio::fs) ve ağlar (tokio::net) için engelleyici olmayan G/Ç işlemleri sağlar.

Bu araçlar, Rust'ta yüksek eşzamanlılığa sahip ve duyarlı uygulamalar oluşturmak için temel niteliktedir. Pratik yapmaya devam edin!

Başlamak ücretsiz

Yapay zeka eğitmeniyle Rust öğren — ücretsiz

Tarayıcında gerçek kod yaz ve çalıştır, 7/24 yapay zeka eğitmeninden anında yardım al; web'de ya da uygulamada kaldığın yerden devam et.

Kurslar
39
Dersler
144
Ücretsiz öğrenmeye başlaTüm kursu görüntüle

Sıkça Sorulan Sorular

“Tokio ile Eşzamansız Uygulamalar Geliştirme” dersi ücretsiz mi?

Evet — “Tokio ile Eşzamansız Uygulamalar Geliştirme” 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.

“Tokio ile Eşzamansız Uygulamalar Geliştirme” dersinde ne öğreneceğim?

G/Ç ve diğer eşzamanlı işlemleri yöneterek eşzamansız görevleri verimli biçimde yürütmek için Tokio çalışma zamanını kullanı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 2. dersidir.

“Tokio ile Eşzamansız Uygulamalar Geliştirme” 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