Learn Rust Coding · Pelajaran

Membuat Thread

Jalankan kode secara serentak.

Membuat Thread adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. 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 4 pelajaran total.

Apa Itu Utas?

Utas memungkinkan program Anda menjalankan kode secara bersamaan. Sistem operasi dapat menjadwalkan beberapa utas, sehingga pekerjaan dapat berlangsung tumpang tindih.

Pustaka standar Rust menyediakan utas melalui modul std::thread. Ini adalah utas OS asli, yang terkadang disebut utas 1:1.

Dalam pelajaran ini, Anda akan belajar memulai utas baru dan mengatur cara kerjanya.

Membuat Utas dengan thread::spawn

Anda membuat utas baru dengan memanggil thread::spawn dan memberinya sebuah penutupan. Penutupan tersebut berisi kode yang akan dijalankan oleh utas baru.

Pemanggilan ini segera mengembalikan JoinHandle, sementara utas yang dibuat berjalan di latar belakang.

use std::thread;

fn main() {
    thread::spawn(|| {
        println!("hello from a thread");
    });
    println!("hello from main");
}

main Mungkin Selesai Lebih Dahulu

Ketika main mengembalikan nilai, seluruh proses berakhir, meskipun utas yang dibuat masih berjalan.

Jadi, program di atas mungkin hanya mencetak pesan utama. Utas latar belakang mungkin tidak sempat berjalan sebelum proses berakhir.

Kita memerlukan cara untuk menunggu hingga utas selesai.

Menunggu dengan join

JoinHandle yang dikembalikan oleh spawn memiliki metode join. Memanggilnya akan memblokir utas saat ini hingga utas yang dibuat selesai.

Ini menjamin utas yang dibuat berjalan sampai selesai sebelum main melanjutkan.

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        println!("worker done");
    });
    handle.join().unwrap();
    println!("main done");
}

Keluaran yang Saling Berselang

Ketika dua utas berjalan sekaligus, keluarannya dapat saling berselang dengan cara yang tidak dapat diprediksi. OS menentukan jadwalnya.

Menjalankan program yang sama dua kali dapat menghasilkan urutan yang berbeda. Jangan pernah bergantung pada urutan tertentu tanpa sinkronisasi.

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        for i in 1..4 {
            println!("thread: {}", i);
        }
    });
    for i in 1..4 {
        println!("main: {}", i);
    }
    handle.join().unwrap();
}

Menjeda dengan sleep

Anda dapat menjeda utas dengan thread::sleep, yang menerima Duration. Tindakan ini menyerahkan CPU agar utas lain dapat melanjutkan pekerjaan.

Tidur berguna dalam contoh agar keluaran yang saling berselang lebih terlihat, tetapi hindari cara ini untuk sinkronisasi nyata.

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

fn main() {
    thread::spawn(|| {
        for i in 1..4 {
            println!("spawned: {}", i);
            thread::sleep(Duration::from_millis(1));
        }
    });
    thread::sleep(Duration::from_millis(10));
}

Membuat Banyak Utas

Anda dapat membuat beberapa utas dalam sebuah perulangan dan mengumpulkan penanganannya ke dalam vektor.

Kemudian, Anda melakukan iterasi pada vektor tersebut dan memanggil join untuk setiap penangan, sehingga semua utas selesai sebelum program berakhir.

use std::thread;

fn main() {
    let mut handles = vec![];
    for id in 0..3 {
        let h = thread::spawn(move || {
            println!("thread {}", id);
        });
        handles.push(h);
    }
    for h in handles {
        h.join().unwrap();
    }
}

Memberi Nama Utas dengan Builder

Tipe thread::Builder memungkinkan Anda mengonfigurasi utas sebelum membuatnya. Anda dapat menetapkan nama dan ukuran tumpukan.

Utas bernama membuat pesan kepanikan dan proses penelusuran kesalahan lebih mudah dibaca.

use std::thread;

fn main() {
    let h = thread::Builder::new()
        .name("worker".into())
        .spawn(|| {
            println!("running in named thread");
        })
        .unwrap();
    h.join().unwrap();
}

Kepanikan Tetap Berada di Dalam Utas

Jika utas yang dibuat mengalami kepanikan, seluruh program tidak akan mengalami kerusakan secara bawaan. Kepanikan tersebut hanya berada di dalam utas itu.

Ketika Anda memanggil join pada utas yang mengalami kepanikan, Anda mendapatkan Err. Dengan begitu, induk dapat mendeteksi kegagalan tersebut.

use std::thread;

fn main() {
    let h = thread::spawn(|| {
        panic!("boom");
    });
    let result = h.join();
    println!("joined, is_err = {}", result.is_err());
}

Informasi Utas Saat Ini

Anda dapat memeriksa utas yang sedang berjalan dengan thread::current. Fungsi ini mengembalikan penangan yang metode name-nya memberikan nama utas jika ada.

Utas utama juga merupakan utas nyata, dan biasanya diberi nama main.

use std::thread;

fn main() {
    let current = thread::current();
    println!("name: {:?}", current.name());
}

Mengembalikan Nilai dari Utas

Penutupan yang diberikan kepada spawn dapat mengembalikan sebuah nilai. Nilai tersebut dikembalikan dalam bentuk Ok ketika Anda memanggil join.

Ini adalah cara sederhana untuk menghitung sesuatu di utas lain dan membaca hasilnya nanti.

use std::thread;

fn main() {
    let h = thread::spawn(|| {
        let sum: i32 = (1..=10).sum();
        sum
    });
    let total = h.join().unwrap();
    println!("total = {}", total);
}

Pemeriksaan Singkat

Uji pemahaman Anda tentang pembuatan utas.

Ringkasan

Anda telah mempelajari cara memulai utas dengan thread::spawn dan sebuah penutupan, yang mengembalikan JoinHandle.

Memanggil join menunggu hingga selesai dan memberikan nilai kembalian atau kepanikan. Keluaran antarutas dapat saling berselang secara tidak terduga, dan Builder memungkinkan Anda memberi nama pada utas.

Selanjutnya, Anda akan melihat cara memindahkan data ke dalam utas yang Anda buat.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Membuat Thread” gratis?

Ya — teks lengkap “Membuat Thread” 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 4 pelajaran total.

Apa yang akan aku pelajari di “Membuat Thread”?

Jalankan kode secara serentak. 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 1 dari 4.

Berapa lama pelajaran “Membuat Thread” 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

← Kembali ke Learn Rust Coding