0Pricing
Learn Rust Coding · Pelajaran

Membangun Aplikasi Asinkron dengan Tokio

Manfaatkan runtime Tokio untuk menjalankan tugas asinkron secara efisien serta menangani I/O dan operasi konkuren lainnya.

Membangun Aplikasi Asinkron dengan Tokio adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 2 dari 3. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Learn Rust Coding, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Learn Rust Coding mencakup 3 pelajaran total.

Mengenal Runtime Tokio

Selamat datang kembali! Pada pelajaran sebelumnya, Anda telah mempelajari async dan await. Namun, bagaimana sebenarnya fungsi async dijalankan?

Di sinilah runtime asinkron seperti Tokio berperan. Tokio adalah pustaka andal yang menyediakan lingkungan eksekusi untuk kode Rust asinkron Anda.

  • Menjadwalkan dan menjalankan Future.
  • Menangani operasi I/O tanpa pemblokiran.
  • Mengelola tugas-tugas bersamaan secara efisien.

Menjalankan Kode Async Anda

Untuk mulai menggunakan Tokio, biasanya Anda menggunakan makro atribut #[tokio::main]. Makro ini mengubah async fn main() menjadi fn main() standar yang menginisialisasi runtime Tokio dan menjalankan kode asinkron Anda.

Anggaplah ini sebagai titik masuk untuk aplikasi async Anda.

use tokio;

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

Membuat Tugas Async Baru

Salah satu fitur inti Tokio adalah kemampuan menjalankan beberapa operasi asinkron secara bersamaan. Anda dapat melakukannya menggunakan tokio::spawn.

tokio::spawn menerima sebuah Future dan menjadwalkannya untuk dijalankan pada runtime Tokio. Dengan demikian, tugas utama Anda dapat terus berjalan sementara tugas yang dibuat berjalan di latar belakang.

  • Tidak menghambat.
  • Mengembalikan JoinHandle untuk menunggu hingga tugas selesai.
  • Tugas berjalan secara mandiri.

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

Mari kita lihat bagaimana tokio::spawn memungkinkan Anda menjalankan kode secara bersamaan. Perhatikan bahwa kedua pesan akan muncul, tetapi pesan 'done' mungkin tercetak sebelum pesan 'task complete' karena adanya 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 Beberapa Tugas

Ketika memiliki beberapa tugas, Anda sering perlu menunggu semuanya selesai. Tokio menyediakan makro tokio::join! untuk tujuan ini.

tokio::join! memungkinkan Anda menunggu beberapa future secara bersamaan dan menggabungkan hasilnya. Fungsinya mirip dengan melakukan `await` pada beberapa `JoinHandle`, tetapi biasanya lebih ringkas untuk kumpulan future yang jumlahnya 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 File Async dengan Tokio

Operasi file tradisional dapat menghambat thread, yang tidak baik untuk aplikasi async. Modul tokio::fs milik Tokio menyediakan versi asinkron dari operasi sistem file.

Dengan demikian, aplikasi Anda tetap responsif saat membaca file besar atau melakukan banyak operasi file, karena I/O ditangani tanpa pemblokiran.

  • tokio::fs::read_to_string
  • tokio::fs::write
  • tokio::fs::File untuk kontrol yang lebih besar

Membaca File Secara Asinkron

Berikut cara membaca file secara asinkron menggunakan tokio::fs::read_to_string. Agar kode ini dapat dijalankan, pastikan Anda memiliki file bernama hello.txt di direktori yang sama dengan proyek Rust Anda (misalnya, di dalam src/ atau di root proyek) yang berisi teks.

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 Jaringan Async

Tokio benar-benar unggul dalam pemrograman jaringan. Modul tokio::net menyediakan primitif tanpa pemblokiran untuk komunikasi TCP dan UDP.

Hal ini penting untuk membangun server atau klien berperforma tinggi yang dapat menangani banyak koneksi secara bersamaan tanpa thread terpisah untuk setiap koneksi.

  • tokio::net::TcpListener untuk server.
  • tokio::net::TcpStream untuk koneksi klien.

Struktur Dasar Server TCP Async

Meskipun server lengkap cukup kompleks, cuplikan ini menunjukkan perulangan inti server TCP async menggunakan Tokio. Server ini mendengarkan koneksi masuk dan mencetak pesan untuk setiap koneksi. Coba jalankan kode ini, lalu buka peramban Anda ke http://127.0.0.1:8080 untuk melihat koneksi.

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

Tantangan Tugas Tokio

Perhatikan kode Rust berikut yang menggunakan Tokio. Apa pesan *pertama* yang dicetak ke konsol saat program 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.");
}

Ringkasan: Membangun dengan Tokio

Anda telah mengambil langkah penting dalam membangun aplikasi asinkron dengan Rust dan Tokio!

  • Tokio berperan sebagai runtime async yang menjalankan kode async Anda.
  • #[tokio::main] adalah titik masuk async program Anda.
  • tokio::spawn memungkinkan Anda menjalankan beberapa tugas secara bersamaan.
  • tokio::join! membantu menunggu beberapa future.
  • Tokio menyediakan I/O tanpa pemblokiran untuk file (tokio::fs) dan jaringan (tokio::net).

Alat-alat ini merupakan dasar penting untuk membuat aplikasi Rust yang sangat konkuren dan responsif. Teruslah berlatih!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Membangun Aplikasi Asinkron dengan Tokio” gratis?

Ya — teks lengkap “Membangun Aplikasi Asinkron dengan Tokio” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Learn Rust Coding, upgrade ke CoddyKit PRO. Kursus Learn Rust Coding mencakup 3 pelajaran total.

Apa yang akan aku pelajari di “Membangun Aplikasi Asinkron dengan Tokio”?

Manfaatkan runtime Tokio untuk menjalankan tugas asinkron secara efisien serta menangani I/O dan operasi konkuren lainnya. Kamu berlatih Learn Rust Coding dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Learn Rust Coding?

Tidak diperlukan pengalaman sebelumnya. Learn Rust Coding di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 3.

Berapa lama pelajaran “Membangun Aplikasi Asinkron dengan Tokio” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Learn Rust Coding ini?

Ya. Setiap pelajaran Learn Rust Coding menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Pengantar Async/Await
  2. Membangun Aplikasi Asinkron dengan Tokio
  3. Bekerja dengan Future dan Tugas
← Kembali ke Learn Rust Coding