Panduan untuk Konkurensi Tak Takut Rust
Table of content:
Concurrency adalah kemampuan suatu program untuk menjalankan banyak tugas secara bersamaan pada inti CPU yang sama. Tugas bersamaan berjalan dan selesai dalam waktu yang tumpang tindih tanpa urutan yang ditentukan, tidak seperti paralelisme, di mana berbagai tugas atau subtugas dari tugas yang sama berjalan pada waktu yang sama pada perangkat keras dengan banyak prosesor.
Rust menonjol karena fitur kinerjanya dan dukungan untuk konkurensi dengan cara yang aman dan efisien. Pendekatan Rust terhadap konkurensi didasarkan pada konsep “konkurensi tanpa rasa takut” di mana bahasa tersebut bertujuan untuk memudahkan penulisan kode konkuren yang aman melalui sistem kepemilikan dan peminjamannya yang menerapkan aturan ketat pada waktu kompilasi untuk mencegah pelacakan data dan memastikan keamanan memori.
Baca Juga:
Memahami Konkurensi dalam Rust
Rust menyediakan beberapa primitif konkurensi untuk menulis program bersamaan, termasuk utas, pengiriman pesan, mutex, tipe atom, dan async/menunggu untuk pemrograman asinkron.
Berikut ini ikhtisar konkurensi primitif Rust:
- Utas: Karat menyediakan a std::utas modul di pustaka standarnya untuk membuat dan mengelola utas. Anda dapat menelurkan utas baru dengan benang::bertelur fungsi. Itu benang::bertelur mengambil penutupan yang berisi kode untuk dieksekusi. Anda juga dapat menjalankan utas yang dapat berjalan secara paralel, dan Rust menyediakan primitif sinkronisasi untuk mengoordinasikan eksekusinya. Pemeriksa pinjaman memastikan bahwa referensi tidak mengarah pada perilaku yang tidak diharapkan.
- Pesan Lewat: Model konkurensi Rust mendukung pengiriman pesan antar utas. Anda akan menggunakan saluran yang diterapkan melalui std::sinkronisasi::mpsc modul untuk menyampaikan pesan. Saluran terdiri dari pemancar (Pengirim) dan penerima (Penerima). Utas dapat mengirim pesan melalui pemancar dan menerimanya melalui penerima. Ini memberikan cara komunikasi yang aman dan tersinkronisasi antar utas.
- Mutex dan Jenis Atom: Rust menyediakan primitif sinkronisasi, termasuk mutex (std::sinkronisasi::Mutex) dan jenis atom (std::sync::atomik), untuk memastikan akses berbagi data eksklusif. Mutex memungkinkan banyak utas untuk mengakses data secara bersamaan sambil mencegah balapan data. Tipe atom memberikan operasi atom pada data bersama, seperti penambahan penghitung, tanpa memerlukan penguncian eksplisit.
- Async/Menunggu dan Berjangka: karat asinkron/menunggu sintaks menyediakan fungsionalitas untuk menulis kode asinkron yang dapat Anda jalankan secara bersamaan. Program asinkron secara efisien menangani tugas yang terikat I/O yang memungkinkan program melakukan tugas lain sambil menunggu operasi I/O lainnya. Karat asinkron/menunggu sintaks didasarkan pada masa depan, dan Anda dapat memberdayakannya dengan async-std atau tokio perpustakaan runtime.
Ulir karat ringan, dan tidak adanya overhead runtime membuatnya sangat cocok untuk aplikasi berperforma tinggi. Primitif konkurensi Rust berintegrasi mulus dengan banyak pustaka dan kerangka kerja untuk kebutuhan konkurensi yang berbeda.
Cara Menggunakan Spawn Threads di Rust
Anda akan menggunakan std::utas modul untuk menelurkan utas. Itu std::utas::memunculkan fungsi memungkinkan Anda membuat utas baru yang akan berjalan bersamaan dengan utas utama atau utas lain yang ada di program Anda.
Inilah cara Anda dapat menelurkan utas dengan std::utas::memunculkan fungsi:
use std::thread;fn main() {
let thread_handle = thread::spawn(|| {
println!("Hello from the new thread!");
});
thread_handle.join().unwrap();
println!("Hello from the main thread!");
}
Itu utama fungsi membuat utas baru dengan benang::bertelur fungsi dengan meneruskan penutupan yang berisi kode untuk eksekusi di utas (dalam hal ini, penutupan adalah fungsi anonim). Penutupan mencetak pesan yang menunjukkan bahwa utas baru sedang berjalan.
Itu bergabung metode pada thread_handle memungkinkan utas utama menunggu utas yang dihasilkan menyelesaikan eksekusi. Dengan menyebut bergabungfungsi memastikan bahwa utas utama menunggu utas yang dihasilkan selesai sebelum melanjutkan.
Anda dapat menelurkan banyak utas dan menggunakan loop atau struktur kontrol Rust lainnya untuk membuat banyak penutupan dan menelurkan utas untuk masing-masing.
use std::thread;fn main() {
let num_threads = 5;
let mut thread_handles = vec![];
for i in 0..num_threads {
let thread_handle = thread::spawn(move || {
println!("Hello from thread {}", i);
});
thread_handles.push(thread_handle);
}
for handle in thread_handles {
handle.join().unwrap();
}
println!("All threads finished!");
}
Perulangan for memunculkan lima utas, masing-masing ditetapkan ke pengidentifikasi unik Saya dengan variabel loop. Penutupan menangkap nilai Saya dengan bergerak kata kunci untuk menghindari masalah kepemilikan, dan thread_handles vektor menyimpan utas untuk nanti di bergabung lingkaran.
Setelah menelurkan semua utas, file utama fungsi berulang selama thread_handles vektor, panggilan bergabung pada setiap pegangan, dan menunggu semua utas dieksekusi.
Melewati Pesan Melalui Saluran
Anda dapat menyampaikan pesan melalui utas dengan saluran. Rust menyediakan fungsionalitas untuk pengiriman pesan di std::sinkronisasi::mpsc modul. Di Sini, mpsc singkatan dari “multiple producer, single consumer” dan memungkinkan komunikasi antara beberapa thread dengan mengirim dan menerima pesan melalui saluran.
Inilah cara Anda menerapkan pesan yang melewati saluran komunikasi antar-utas dalam program Anda:
use std::sync::mpsc;
use std::thread;fn main() {
let (sender, receiver) = mpsc::channel();
thread::spawn(move || {
sender.send("Hello from the thread!").unwrap();
});
let received_message = receiver.recv().unwrap();
println!("Received message: {}", received_message);
}
Itu utama fungsi membuat saluran dengan mpsc::saluran() yang mengembalikan a pengirim dan a penerima. Itu pengirim mengirim pesan ke penerima yang menerima pesan. Itu utama fungsi hasil untuk menelurkan utas dan memindahkan kepemilikan Pengirim ke penutupan benang. Di dalam penutupan utas, itu pengirim.kirim() fungsi mengirim pesan melalui saluran.
Itu penerima.recv() fungsi menerima pesan dengan menghentikan eksekusi sampai utas menerima pesan. Itu utama fungsi mencetak pesan ke konsol setelah penerimaan pesan berhasil.
Perhatikan bahwa mengirim pesan melalui saluran menghabiskan pengirim. Jika Anda perlu mengirim pesan dari beberapa utas, Anda dapat mengkloning pengirim dengan pengirim.clone() fungsi.
Selain itu, mpsc modul menyediakan metode lain seperti try_recv()yang non-pemblokiran mencoba menerima pesan, dan iter()yang membuat iterator di atas pesan yang diterima.
Pengiriman pesan melalui saluran menyediakan cara yang aman dan nyaman untuk berkomunikasi antar utas sambil menghindari perlombaan data dan memastikan sinkronisasi yang tepat.
Model Kepemilikan dan Peminjaman Rust Menjamin Keamanan Memori
Rust menggabungkan kepemilikan, peminjaman, dan pemeriksa pinjaman untuk menyediakan kerangka kerja pemrograman yang kuat, aman, dan bersamaan.
Pemeriksa pinjaman bertindak sebagai jaring pengaman, mendeteksi potensi masalah pada waktu kompilasi daripada mengandalkan pemeriksaan waktu proses atau pengumpulan sampah.
Artikel Terkait
