Berkongsi dengan Arc dan Mutex
Ubah keadaan dikongsi dengan selamat.
Berkongsi dengan Arc dan Mutex ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 3 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.
Keperluan Keadaan Dikongsi
Kadang-kadang beberapa utas perlu membaca atau mengemas kini data yang sama. Memindahkan pemilikan kepada satu utas sahaja tidak mencukupi.
Rust memberi anda pemilikan dikongsi yang selamat merentas utas dengan Arc, serta pengubahsuaian yang selamat dengan Mutex. Bersama-sama, kedua-duanya membolehkan keadaan yang boleh diubah suai dan dikongsi.
Arc: Pengiraan Rujukan Atomik
Arc bermaksud pengiraan rujukan secara atomik. Ia seperti Rc, tetapi pembilangnya menggunakan operasi atomik, jadi ia selamat merentas utas.
Mengklon Arc tidak menyalin data. Ia hanya menambah kiraan dan mengembalikan satu lagi pemegang kepada nilai yang sama.
use std::sync::Arc;
fn main() {
let shared = Arc::new(vec![1, 2, 3]);
let clone = Arc::clone(&shared);
println!("{:?} {:?}", shared, clone);
}Berkongsi Arc Merentas Utas
Untuk berkongsi data baca sahaja, klon Arc sekali bagi setiap utas dan pindahkan setiap klon ke dalamnya. Semua utas menunjuk kepada peruntukan yang sama.
Oleh sebab Arc ialah Send dan Sync, kod ini berjaya dikompil tanpa masalah.
use std::sync::Arc;
use std::thread;
fn main() {
let data = Arc::new(vec![10, 20, 30]);
let mut handles = vec![];
for i in 0..3 {
let d = Arc::clone(&data);
handles.push(thread::spawn(move || println!("{}", d[i])));
}
for h in handles { h.join().unwrap(); }
}Arc Sahaja Adalah Baca Sahaja
Arc memberi anda pemilikan dikongsi, tetapi hanya akses dikongsi dan tidak boleh diubah suai kepada nilai dalaman.
Anda tidak boleh mengubah data secara langsung melalui Arc, kerana beberapa utas yang memegangnya serentak boleh menyebabkan perlumbaan. Anda memerlukan kebolehubahan dalaman dengan kunci.
Mutex: Saling Mengecualikan
Mutex melindungi data supaya hanya satu utas boleh mengaksesnya pada satu-satu masa. Anda memanggil lock untuk mendapatkan akses.
lock mengembalikan Result; melakukan unwrap menghasilkan pengawal penunjuk pintar. Utas lain disekat sehingga pengawal itu digugurkan.
use std::sync::Mutex;
fn main() {
let m = Mutex::new(0);
{
let mut guard = m.lock().unwrap();
*guard += 5;
}
println!("{:?}", m);
}Pengawal dan RAII
Nilai yang dikembalikan oleh lock ialah MutexGuard. Anda mengakses data dalaman dengan menyahrujuknya menggunakan *.
Apabila pengawal keluar daripada skop, kunci dilepaskan secara automatik. Gaya RAII ini menghalang anda daripada terlupa membuka kunci.
Menggabungkan Arc dan Mutex
Untuk berkongsi keadaan yang boleh diubah suai merentas utas, bungkus Mutex di dalam Arc. Arc berkongsi pemilikan; Mutex melindungi pengubahsuaian.
Pola Arc<Mutex<T>> ini ialah cara standard untuk melaksanakan keadaan yang boleh diubah suai dan dikongsi dalam Rust.
use std::sync::{Arc, Mutex};
fn main() {
let counter = Arc::new(Mutex::new(0));
let c = Arc::clone(&counter);
*c.lock().unwrap() += 1;
println!("{}", *counter.lock().unwrap());
}Pembilang Dikongsi
Di sini, sepuluh utas masing-masing menambah satu pada pembilang yang dikongsi. Setiap utas mengklon Arc, mengunci Mutex, lalu menambah satu.
Oleh sebab kunci menyusun akses secara bersiri, jumlah akhir sentiasa tepat sepuluh.
use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];
for _ in 0..10 {
let c = Arc::clone(&counter);
handles.push(thread::spawn(move || {
*c.lock().unwrap() += 1;
}));
}
for h in handles { h.join().unwrap(); }
println!("{}", *counter.lock().unwrap());
}Pastikan Bahagian Kritikal Pendek
Kod yang dijalankan semasa kunci dipegang ialah bahagian kritikal. Utas lain menunggu di situ, jadi pastikan bahagian ini pendek.
Kunci, lakukan kemas kini minimum, kemudian lepaskan kunci. Elakkan pengiraan berat atau input/output semasa memegang kunci.
use std::sync::Mutex;
fn main() {
let m = Mutex::new(Vec::new());
{
let mut v = m.lock().unwrap();
v.push(1);
} // lock released here
println!("{:?}", m.lock().unwrap());
}Jalan Buntu dan Keracunan
Jika satu utas mengunci Mutex yang sama dua kali, atau dua utas mengunci dua mutex dalam susunan yang bertentangan, program boleh mengalami jalan buntu dan tergantung selama-lamanya.
Jika satu utas mengalami panik semasa memegang kunci, Mutex menjadi tercemar, dan panggilan lock seterusnya mengembalikan Err.
RwLock untuk Banyak Pembaca
Apabila bacaan jauh lebih banyak daripada penulisan, RwLock mungkin lebih baik daripada Mutex. Ia membenarkan ramai pembaca serentak atau seorang penulis eksklusif.
Gunakan read untuk akses dikongsi dan write untuk akses eksklusif.
use std::sync::RwLock;
fn main() {
let lock = RwLock::new(5);
{
let r = lock.read().unwrap();
println!("read {}", *r);
}
*lock.write().unwrap() += 1;
println!("{}", *lock.read().unwrap());
}Semakan Pantas
Uji pemahaman anda tentang Arc dan Mutex.
Imbas Kembali
Anda telah mempelajari bahawa Arc berkongsi pemilikan merentas utas melalui pengiraan rujukan atomik, tetapi hanya membenarkan akses yang tidak boleh diubah suai.
Mutex melindungi pengubahsuaian dan memberikan pengawal yang dilepaskan apabila digugurkan. Gabungkan kedua-duanya sebagai Arc<Mutex<T>> untuk keadaan yang boleh diubah suai dan dikongsi, sambil berwaspada terhadap jalan buntu dan keracunan.
Seterusnya, anda akan menyertai utas dan mengumpulkan hasilnya.
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 “Berkongsi dengan Arc dan Mutex” percuma?
Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Berkongsi dengan Arc dan Mutex”, 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 “Berkongsi dengan Arc dan Mutex”?
Ubah keadaan dikongsi dengan selamat. 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 3 daripada 4.
Berapa lamakah pelajaran “Berkongsi dengan Arc dan Mutex” 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