Belajar Pengaturcaraan Rust · Pelajaran

Membina Aplikasi Tak Segerak dengan Tokio

Gunakan masa jalan Tokio untuk melaksanakan tugasan tak segerak dengan cekap, termasuk operasi IO dan operasi serentak lain.

Pelajaran 2 daripada 311 langkah

Membina Aplikasi Tak Segerak dengan Tokio ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 2 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.

Kenali Masa Jalan Tokio

Selamat datang kembali! Dalam pelajaran sebelumnya, anda telah mempelajari tentang async dan await. Tetapi bagaimanakah fungsi async sebenarnya berjalan?

Di sinilah masa jalan tak segerak seperti Tokio digunakan. Tokio ialah pustaka berkuasa yang menyediakan persekitaran pelaksanaan untuk kod Rust tak segerak anda.

Ia menjadualkan dan melaksanakan Future.
Mengendalikan operasi I/O tanpa sekatan.
Mengurus tugas serentak dengan cekap.

Menjalankan Kod Async Anda

Untuk bermula dengan Tokio, anda biasanya menggunakan makro atribut #[tokio::main]. Makro ini mengubah async fn main() anda menjadi fn main() standard yang memulakan masa jalan Tokio dan menjalankan kod tak segerak anda.

Anggaplah ia sebagai titik masuk untuk aplikasi async anda.

use tokio;

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

Mencipta Tugas Async Baharu

Salah satu ciri teras Tokio ialah keupayaan menjalankan berbilang operasi tak segerak secara serentak. Anda boleh melakukannya menggunakan tokio::spawn.

tokio::spawn menerima satu Future dan menjadualkannya untuk berjalan pada masa jalan Tokio. Ini membolehkan tugas utama anda terus dilaksanakan sementara tugas yang dicipta berjalan di latar belakang.

Ia tidak menyekat.
Mengembalikan JoinHandle untuk menunggu penyelesaiannya.
Tugas berjalan secara bebas.

<code>tokio::spawn</code> dalam Tindakan

Mari lihat bagaimana tokio::spawn membolehkan anda melaksanakan kod secara serentak. Perhatikan bahawa kedua-dua mesej dipaparkan, tetapi mesej 'done' mungkin dicetak sebelum mesej 'task complete' kerana jeda.

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

Menunggu Berbilang Tugas

Apabila anda mempunyai berbilang tugas, anda sering perlu menunggu sehingga kesemuanya selesai. Tokio menyediakan makro tokio::join! untuk tujuan ini.

tokio::join! membolehkan anda menunggu beberapa future secara serentak dan menggabungkan hasilnya. Ia serupa dengan menunggu beberapa JoinHandle menggunakan `await`, tetapi biasanya lebih ringkas untuk set future yang tetap.

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

I/O Fail Async dengan Tokio

Operasi fail tradisional boleh menyekat bebenang, yang tidak baik untuk aplikasi async. Modul tokio::fs Tokio menyediakan versi tak segerak bagi operasi sistem fail.

Ini membolehkan aplikasi anda kekal responsif walaupun ketika membaca fail besar atau melakukan banyak operasi fail, kerana I/O dikendalikan secara tidak menyekat.

tokio::fs::read_to_string
tokio::fs::write
tokio::fs::File untuk kawalan yang lebih terperinci

Membaca Fail Secara Tak Segerak

Begini cara anda boleh membaca fail secara tak segerak menggunakan tokio::fs::read_to_string. Agar kod ini dapat dijalankan, pastikan anda mempunyai fail bernama hello.txt dalam direktori yang sama dengan projek Rust anda (contohnya, di dalam src/ atau di akar projek) yang mengandungi kandungan.

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

Operasi Rangkaian Async

Tokio benar-benar menyerlah dalam pengaturcaraan rangkaian. Modul tokio::net menyediakan primitif tanpa sekatan untuk komunikasi TCP dan UDP.

Ini penting untuk membina pelayan atau klien berprestasi tinggi yang boleh mengendalikan banyak sambungan secara serentak tanpa bebenang berasingan untuk setiap sambungan.

tokio::net::TcpListener untuk pelayan.
tokio::net::TcpStream untuk sambungan klien.

Struktur Asas Pelayan TCP Async

Walaupun pelayan penuh adalah kompleks, coretan ini menunjukkan gelung teras pelayan TCP tak segerak menggunakan Tokio. Ia mendengar sambungan masuk dan mencetak mesej untuk setiap sambungan. Cuba jalankannya, kemudian buka pelayar anda ke http://127.0.0.1:8080 untuk melihat sambungan.

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

Cabaran Tugas Tokio

Pertimbangkan kod Rust berikut yang menggunakan Tokio. Apakah mesej *pertama* yang dicetak pada konsol apabila atur cara ini dijalankan?

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

Jawab dalam pelajaran interaktif

Imbas Kembali: Membina dengan Tokio

Anda telah mengambil langkah penting dalam membina aplikasi tak segerak dengan Rust dan Tokio!

Tokio bertindak sebagai masa jalan async, yang melaksanakan kod async anda.
#[tokio::main] ialah titik masuk async atur cara anda.
tokio::spawn membolehkan anda menjalankan berbilang tugas secara serentak.
tokio::join! membantu menunggu berbilang future.
Tokio menyediakan I/O tanpa sekatan untuk fail (tokio::fs) dan rangkaian (tokio::net).

Alat ini penting untuk mencipta aplikasi Rust yang sangat serentak dan responsif. Teruskan berlatih!

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 “Membina Aplikasi Tak Segerak dengan Tokio” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Membina Aplikasi Tak Segerak dengan Tokio”, 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 “Membina Aplikasi Tak Segerak dengan Tokio”?

Gunakan masa jalan Tokio untuk melaksanakan tugasan tak segerak dengan cekap, termasuk operasi IO dan operasi serentak lain. 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 2 daripada 3.

Berapa lamakah pelajaran “Membina Aplikasi Tak Segerak dengan Tokio” 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