PricingLoginStart free
Belajar Pengaturcaraan Rust · Pelajaran

Mengendalikan Future dan Tugasan

Fahami trait `Future` serta cara tugasan dijadualkan dan diurus dalam persekitaran masa jalan tak segerak.

Pelajaran 3 daripada 311 langkah

Mengendalikan Future dan Tugasan ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 3 daripada 3. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Belajar Pengaturcaraan Rust, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 3 pelajaran.

Apakah Future Rust?

Dalam Rust tak segerak, Future ialah trait yang mewakili pengiraan tak segerak yang mungkin selesai pada suatu ketika. Anggaplah ia sebagai janji untuk nilai yang masih belum sedia.

  • Ia ialah blok binaan teras untuk Rust async.
  • async fn dalam Rust sebenarnya mengembalikan jenis tanpa nama yang melaksanakan trait Future.
  • Nilai itu tidak dikira serta-merta; ia dikira apabila Future "ditinjau" oleh pelaksana.

Cara Future Membuat Kemajuan

Future tidak berjalan dengan sendiri. Pelaksana seperti masa jalan Tokio berulang kali "meninjau"nya untuk memeriksa sama ada ia telah membuat kemajuan atau selesai.

  • Apabila ditinjau, Future mengembalikan sama ada Poll::Pending (belum selesai) atau Poll::Ready(T) (selesai, inilah hasilnya).
  • Jika Pending, pelaksana tahu untuk meninjaunya semula kemudian apabila sesuatu yang berkaitan berlaku (contohnya, I/O selesai).
  • Mekanisme tinjauan ini membolehkan banyak operasi tak segerak berjalan serentak pada satu bebenang.

Kod async Anda ialah Future

Apabila anda menulis async fn, Rust mengubahnya menjadi mesin keadaan yang melaksanakan trait Future. Pengiraan sebenar hanya bermula apabila Future yang dikembalikan ditinjau.

Mari lihat fungsi async yang ringkas. Ia tidak berjalan sehingga ditunggu oleh pelaksana.

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 Menjadi Tugas

Walaupun Future ialah takrifan pengiraan async, tugas ialah contoh aktif Future itu yang digerakkan hingga selesai oleh pelaksana.

  • Apabila anda mengarahkan pelaksana seperti Tokio untuk menjalankan Future, ia membungkusnya dalam tugas.
  • Pelaksana kemudian mengurus tugas ini dan meninjaunya setiap kali ia sedia untuk membuat kemajuan.
  • Tugas ialah unit kerja yang dijadualkan dan dilaksanakan secara serentak oleh masa jalan async.

Mencipta Tugas untuk Keserentakan

Untuk menjalankan Future secara serentak dengan kod lain, anda "menciptanya" pada masa jalan Tokio. Ini menghasilkan tugas baharu yang akan diurus oleh masa jalan.

Fungsi tokio::spawn menerima satu Future dan mengembalikan JoinHandle, yang boleh anda gunakan untuk menunggu tugas selesai dan mendapatkan hasilnya.

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);
}

Mendapatkan Hasil daripada Tugas

JoinHandle yang dikembalikan oleh tokio::spawn itu sendiri ialah Future. Anda boleh menggunakan .await pada pemegang ini untuk menunggu tugas yang dicipta selesai dan mendapatkan nilai pulangannya.

Jika tugas yang dicipta mengalami panik, menunggu JoinHandlenya akan mengembalikan ralat.

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.");
}

Berbilang Tugas Serentak

Kuasa tugas dan tokio::spawn benar-benar terserlah apabila anda menjalankan berbilang operasi secara serentak. Masa jalan Tokio bertukar antara tugas dengan cekap apabila tugas tersebut sedia.

Ini membolehkan atur cara anda membuat kemajuan dalam banyak perkara serentak tanpa menyekat, walaupun pada satu bebenang.

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.");
}

Menunggu Kesemuanya dengan join!

Apabila anda perlu menunggu beberapa Future selesai pada masa yang sama, tokio::join! ialah makro yang berguna. Ia menunggu semua future yang diberikan secara serentak dan mengembalikan hasilnya sebagai tuple.

Ia serupa dengan menunggu setiap pemegang secara berasingan, tetapi biasanya lebih ringkas untuk bilangan future yang tetap.

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.");
}

Mengendalikan Ralat Tugas

Operasi tak segerak boleh gagal, sama seperti operasi segerak. Lazimnya Future mengembalikan jenis Result, yang menunjukkan kejayaan atau kegagalan.

Apabila menunggu JoinHandle, ingat bahawa hasilnya dibungkus dalam Result lain kerana tugas itu sendiri mungkin mengalami panik. Anda sering akan melihat handle.await? (jika dalam async fn yang mengembalikan Result) atau handle.await.unwrap() / .expect().

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(())
}

Memahami Future & Tugas

Anda telah mempelajari Future sebagai pengiraan dan Tugas sebagai contoh pelaksanaannya. Pernyataan manakah tentang tokio::spawn dan JoinHandle yang benar?

Jawab dalam pelajaran interaktif

Imbas Kembali: Future dan Tugas

Syabas! Kini anda telah memahami konsep teras Future dan tugas dalam ekosistem tak segerak Rust:

  • Future ialah trait yang mewakili pengiraan tak segerak yang akhirnya akan menghasilkan nilai.
  • async fn dikompil menjadi jenis yang melaksanakan trait Future.
  • Tugas ialah contoh Future yang diurus dan ditinjau secara aktif oleh pelaksana seperti Tokio.
  • tokio::spawn digunakan untuk mencipta tugas baharu dan mengembalikan JoinHandle.
  • Anda menggunakan .await pada JoinHandle untuk mendapatkan hasil tugas yang dicipta.

Blok binaan ini penting untuk menulis aplikasi Rust yang cekap dan tidak menyekat!

Percuma untuk bermula

Pelajari Rust dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus
39
Pelajaran
144
Mula belajar secara percumaLihat kursus penuh

Soalan Lazim

Adakah pelajaran “Mengendalikan Future dan Tugasan” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Mengendalikan Future dan Tugasan”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 3 pelajaran.

Apakah yang akan saya pelajari dalam “Mengendalikan Future dan Tugasan”?

Fahami trait `Future` serta cara tugasan dijadualkan dan diurus dalam persekitaran masa jalan tak segerak. Anda berlatih Belajar Pengaturcaraan Rust menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Belajar Pengaturcaraan Rust?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Belajar Pengaturcaraan Rust di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 3.

Berapa lamakah pelajaran “Mengendalikan Future dan Tugasan” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Belajar Pengaturcaraan Rust ini?

Ya. Setiap pelajaran Belajar Pengaturcaraan Rust menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

  1. Pengenalan kepada Async/Await
  2. Membina Aplikasi Tak Segerak dengan Tokio
  3. Mengendalikan Future dan Tugasan
← Kembali ke Belajar Pengaturcaraan Rust