Belajar Pengaturcaraan Rust · Pelajaran

Pengenalan kepada Async/Await

Pelajari asas fungsi `async` dan ungkapan `await` untuk menulis kod tak segerak yang tidak menyekat.

Pelajaran 1 daripada 311 langkah

Pengenalan kepada Async/Await ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 1 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.

Mengapa Pengaturcaraan Tak Segerak?

Dalam pengaturcaraan, tugasan sering melibatkan penantian. Ini mungkin menunggu fail dimuatkan, permintaan rangkaian selesai atau pertanyaan pangkalan data mengembalikan hasil.

Secara tradisional, atur cara menyekat semasa menunggu, iaitu menjeda semua operasi lain sehingga tugasan selesai. Hal ini boleh menyebabkan aplikasi menjadi perlahan dan tidak responsif.

Apabila Kod Menunggu...

Pertimbangkan contoh mudah operasi yang menyekat ini. Atur cara akan berhenti seketika selama 2 saat sebelum mencetak mesej kedua.

Cuba jalankannya:

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

fn main() {
  println!("Starting a blocking task...");
  thread::sleep(Duration::from_secs(2)); // This blocks!
  println!("Blocking task finished!");
}

Kos Menunggu

Dalam contoh sebelumnya, seluruh atur cara menunggu. Jika ini ialah pelayan web, ini bermakna ketika permintaan seorang pengguna sedang menunggu pangkalan data, tiada pengguna lain dapat dilayan!

Pengaturcaraan tak segerak membolehkan atur cara anda memulakan tugasan yang mengambil masa lama, kemudian beralih kepada kerja lain dan bukannya menunggu. Apabila tugasan yang lama itu sudah bersedia, atur cara boleh menyambungnya.

Pendekatan Tak Segerak Rust

Rust menyediakan ciri bahasa yang berkuasa untuk pengaturcaraan tak segerak: kata kunci async dan await.

Fungsi async ialah fungsi khas yang boleh dijeda dan disambung semula.
.await digunakan di dalam fungsi async untuk menunggu tugasan tak segerak lain selesai tanpa menyekat seluruh atur cara.

Mentakrifkan Fungsi `async`

Anda mengisytiharkan fungsi tak segerak dengan menambahkan kata kunci async sebelum fn. Fungsi async sentiasa mengembalikan Future.

Future ialah nilai yang mungkin belum bersedia. Ia mewakili pengiraan yang akhirnya akan menghasilkan keputusan.

async fn my_async_task() -> u32 {
  // This task will eventually return 42
  42
}

Menjeda dengan `.await`

Kata kunci .await menjadikan pengaturcaraan tak segerak tidak menyekat. Apabila anda menggunakan .await pada Future, fungsi async anda akan:

Menjeda pelaksanaannya sendiri.
Membolehkan atur cara melakukan kerja lain.
Menyambung semula apabila Future yang ditunggu sudah bersedia.

Ia seperti menekan butang jeda pada tugasan semasa anda sementara tugasan lain selesai.

Menjalankan Kod Tak Segerak: Pelaksana

Fungsi async mengembalikan Future, tetapi ia tidak menjalankan kod di dalamnya dengan serta-merta. Future bersifat malas.

Untuk benar-benar menjalankan fungsi async dan melaksanakan Future-nya, anda memerlukan pelaksana. Untuk contoh mudah, kita boleh menggunakan futures::executor::block_on, yang menjalankan Future sehingga selesai pada bebenang semasa.

Program `async`/`await` Pertama Anda

Beginilah cara async, await dan pelaksana mudah berfungsi bersama. Perhatikan cara block_on digunakan dalam main untuk memulakan proses tak segerak.

Contoh ini mensimulasikan kelewatan tak segerak tanpa menyekat bebenang fungsi main (secara konsep; block_on sendiri menyekat sehingga future selesai, tetapi tugasan tak segerak itu sendiri menyerahkan kawalan).

use futures::executor::block_on;
use std::time::Duration;

async fn learn_and_wait() {
  println!("Learning asynchronously...");
  // Simulate an async operation that takes time
  // In a real app, this would be an I/O op
  tokio::time::sleep(Duration::from_secs(1)).await;
  println!("Finished learning!");
}

fn main() {
  println!("Starting main function.");
  block_on(learn_and_wait());
  println!("Main function finished.");
}

Memahami Trait `Future`

Apabila anda menulis async fn my_func(), Rust sebenarnya mengubahnya menjadi mesin keadaan yang melaksanakan trait Future.

Trait Future mempunyai satu kaedah utama, poll, yang dipanggil berulang kali oleh pelaksana untuk menyemak sama ada tugasan bersedia membuat kemajuan. Apabila Future dikenakan .await, ia memberitahu pelaksana untuk melakukan tinjauan terhadap Future lain sehingga selesai.

Semakan Pantas: Asas Async/Await

Anda telah mempelajari asas async dan await. Mari lihat sama ada anda boleh mengenal pasti peranan pentingnya.

Jawab dalam pelajaran interaktif

Imbas Kembali dan Langkah Seterusnya

Syabas! Anda telah mengambil langkah pertama dalam pengaturcaraan Rust tak segerak.

Kita telah melihat bahawa blok kod segerak menyebabkan program menunggu.
Kod tak segerak membolehkan tugas berjalan serentak tanpa menyekat.
Kata kunci async mengisytiharkan fungsi tak segerak, yang mengembalikan Future.
Kata kunci .await menjeda fungsi async sehingga Future sedia.
Pelaksana seperti block_on diperlukan untuk menjalankan Future.

Seterusnya, kita akan mendalami Tokio, iaitu masa jalan dan ekosistem berkuasa untuk membina aplikasi tak segerak dunia sebenar dalam Rust!

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 percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Pengenalan kepada Async/Await” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Pengenalan kepada Async/Await”, 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 “Pengenalan kepada Async/Await”?

Pelajari asas fungsi `async` dan ungkapan `await` untuk menulis kod tak segerak yang tidak menyekat. 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 1 daripada 3.

Berapa lamakah pelajaran “Pengenalan kepada Async/Await” 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

Pengenalan kepada Async/Await
Membina Aplikasi Tak Segerak dengan Tokio
Mengendalikan Future dan Tugasan

← Kembali ke Belajar Pengaturcaraan Rust