Mencipta Thread
Jalankan kod secara serentak.
Mencipta Thread ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. 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 4 pelajaran.
Apakah Itu Thread?
Thread membolehkan program anda menjalankan kod secara serentak. Sistem pengendalian boleh menjadualkan beberapa thread, jadi kerja boleh bertindih.
Pustaka standard Rust menyediakan thread melalui modul std::thread. Thread ini ialah thread OS natif, yang kadangkala dipanggil thread 1:1.
Dalam pelajaran ini, anda akan belajar memulakan thread baharu dan mengawal cara thread tersebut berjalan.
Menghasilkan Thread dengan thread::spawn
Anda mencipta thread baharu dengan memanggil thread::spawn dan memberikannya penutupan. Penutupan itu mengandungi kod yang akan dijalankan oleh thread baharu.
Panggilan tersebut kembali serta-merta dengan JoinHandle, manakala thread yang dihasilkan berjalan di latar belakang.
use std::thread;
fn main() {
thread::spawn(|| {
println!("hello from a thread");
});
println!("hello from main");
}Main Mungkin Selesai Dahulu
Apabila main kembali, seluruh proses berakhir walaupun thread yang dihasilkan masih berjalan.
Jadi, program di atas mungkin hanya mencetak mesej utama. Thread latar belakang mungkin tidak sempat berjalan sebelum proses keluar.
Kita memerlukan cara untuk menunggu thread selesai.
Menunggu dengan join
JoinHandle yang dikembalikan oleh spawn mempunyai kaedah join. Memanggilnya menyekat thread semasa sehingga thread yang dihasilkan selesai.
Ini menjamin thread yang dihasilkan berjalan hingga selesai sebelum main diteruskan.
use std::thread;
fn main() {
let handle = thread::spawn(|| {
println!("worker done");
});
handle.join().unwrap();
println!("main done");
}Output Berselang-seli
Apabila dua thread berjalan serentak, outputnya boleh berselang-seli dengan cara yang tidak dapat diramalkan. OS menentukan jadual pelaksanaan.
Menjalankan program yang sama dua kali mungkin menghasilkan susunan yang berbeza. Jangan bergantung pada susunan tertentu tanpa penyegerakan.
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 boleh menjeda thread dengan thread::sleep, yang menerima Duration. Tindakan ini melepaskan CPU supaya thread lain boleh terus berjalan.
Tidur berguna dalam contoh untuk menjadikan perselangan lebih jelas, tetapi elakkannya untuk penyegerakan sebenar.
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));
}Menghasilkan Banyak Thread
Anda boleh menghasilkan beberapa thread dalam gelung dan mengumpulkan pemegangnya ke dalam vektor.
Kemudian, anda mengulangi vektor itu dan memanggil join pada setiap pemegang, bagi memastikan setiap thread 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();
}
}Menamakan Thread dengan Builder
Jenis thread::Builder membolehkan anda mengkonfigurasi thread sebelum menghasilkannya. Anda boleh menetapkan nama dan saiz tindanan.
Thread yang dinamakan menjadikan mesej panik dan penyahpepijatan 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();
}Panik Kekal dalam Thread
Jika thread yang dihasilkan mengalami panik, seluruh program tidak akan ranap secara lalai. Panik tersebut terkandung dalam thread itu.
Apabila anda memanggil join pada thread yang panik, anda menerima Err. Ini membolehkan induk mengesan kegagalan tersebut.
use std::thread;
fn main() {
let h = thread::spawn(|| {
panic!("boom");
});
let result = h.join();
println!("joined, is_err = {}", result.is_err());
}Maklumat Thread Semasa
Anda boleh memeriksa thread yang sedang berjalan dengan thread::current. Ia mengembalikan pemegang yang kaedah name-nya memberikan nama thread pilihan.
Thread utama juga merupakan thread sebenar dan biasanya dinamakan main.
use std::thread;
fn main() {
let current = thread::current();
println!("name: {:?}", current.name());
}Mengembalikan Nilai daripada Thread
Penutupan yang diberikan kepada spawn boleh mengembalikan nilai. Nilai itu dikembalikan dalam balutan Ok apabila anda memanggil join.
Ini ialah cara mudah untuk mengira sesuatu pada thread lain dan membaca hasilnya kemudian.
use std::thread;
fn main() {
let h = thread::spawn(|| {
let sum: i32 = (1..=10).sum();
sum
});
let total = h.join().unwrap();
println!("total = {}", total);
}Semakan Pantas
Uji pemahaman anda tentang menghasilkan thread.
Rumusan
Anda telah belajar memulakan thread dengan thread::spawn dan penutupan, yang mengembalikan JoinHandle.
Memanggil join menunggu sehingga selesai dan memberikan nilai yang dikembalikan atau panik. Output antara thread boleh berselang-seli secara tidak dapat diramalkan, dan Builder membolehkan anda menamakan thread.
Seterusnya, anda akan melihat cara memindahkan data ke dalam thread yang anda hasilkan.
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
Soalan Lazim
Adakah pelajaran “Mencipta Thread” percuma?
Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Mencipta Thread”, 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 4 pelajaran.
Apakah yang akan saya pelajari dalam “Mencipta Thread”?
Jalankan kod secara serentak. 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 4.
Berapa lamakah pelajaran “Mencipta Thread” 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
- Mencipta Thread
- Memindahkan Data ke dalam Thread
- Berkongsi dengan Arc dan Mutex
- Menyertai dan Mengumpulkan Hasil