Learn Rust Coding · Pelajaran

Berbagi dengan Arc dan Mutex

Ubah keadaan bersama dengan aman.

Berbagi dengan Arc dan Mutex adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 3 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.

Kebutuhan akan State Bersama

Terkadang beberapa thread harus membaca atau memperbarui data yang sama. Memindahkan kepemilikan ke satu thread saja tidaklah cukup.

Rust menyediakan kepemilikan bersama yang aman antarthread dengan Arc, serta mutasi yang aman dengan Mutex. Keduanya memungkinkan penggunaan state yang dapat diubah secara bersama-sama.

Arc: Penghitungan Referensi Atomik

Arc adalah singkatan dari penghitungan referensi atomik. Fungsinya seperti Rc, tetapi penghitungnya menggunakan operasi atomik sehingga aman digunakan antarthread.

Mengkloning Arc tidak menyalin datanya. Tindakan itu hanya menambah penghitung dan mengembalikan handle lain ke 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);
}

Berbagi Arc Antarthread

Untuk berbagi data hanya-baca, klon Arc sekali untuk setiap thread, lalu pindahkan setiap klon ke dalamnya. Semua thread menunjuk ke alokasi yang sama.

Karena Arc bersifat Send dan Sync, kode ini dapat dikompilasi 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 Saja Bersifat Hanya-Baca

Arc memberi Anda kepemilikan bersama, tetapi hanya akses bersama yang tidak dapat diubah ke nilai di dalamnya.

Anda tidak dapat mengubah data secara langsung melalui Arc, karena beberapa thread yang memegangnya secara bersamaan dapat mengalami kondisi balapan. Anda memerlukan mutabilitas interior dengan kunci.

Mutex: Eksklusi Mutual

Mutex melindungi data sehingga hanya satu thread yang dapat mengaksesnya pada satu waktu. Anda memanggil lock untuk mendapatkan akses.

lock mengembalikan Result; melakukan unwrap menghasilkan guard berupa pointer pintar. Thread lain akan menunggu sampai guard dilepas.

use std::sync::Mutex;

fn main() {
    let m = Mutex::new(0);
    {
        let mut guard = m.lock().unwrap();
        *guard += 5;
    }
    println!("{:?}", m);
}

Guard dan RAII

Nilai yang dikembalikan oleh lock adalah MutexGuard. Anda mengakses data di dalamnya dengan melakukan dereferensi menggunakan *.

Saat guard keluar dari scope, kunci dilepaskan secara otomatis. Gaya RAII ini mencegah Anda lupa membuka kunci.

Menggabungkan Arc dan Mutex

Untuk berbagi state yang dapat diubah antarthread, bungkus Mutex di dalam Arc. Arc berbagi kepemilikan, sedangkan Mutex melindungi mutasi.

Pola Arc<Mutex<T>> ini merupakan cara standar untuk menggunakan state yang dapat diubah secara bersama-sama di 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());
}

Counter Bersama

Di sini, sepuluh thread masing-masing menaikkan nilai counter bersama. Setiap thread mengklon Arc, mengunci Mutex, lalu menambahkan satu.

Karena kunci membuat akses berlangsung secara berurutan, total akhirnya selalu 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());
}

Jaga Agar Bagian Kritis Tetap Singkat

Kode yang dijalankan saat kunci dipegang disebut bagian kritis. Thread lain menunggu di sana, jadi buatlah bagian ini tetap singkat.

Kunci, lakukan pembaruan minimal, lalu lepaskan kunci. Hindari komputasi berat atau I/O selama 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());
}

Deadlock dan Poisoning

Jika sebuah thread mengunci Mutex yang sama dua kali, atau dua thread mengunci dua mutex dalam urutan yang berlawanan, Anda dapat mengalami deadlock dan program berhenti tanpa batas.

Jika sebuah thread mengalami panic saat memegang kunci, Mutex menjadi poisoned, dan pemanggilan lock berikutnya mengembalikan Err.

RwLock untuk Banyak Pembaca

Ketika operasi baca jauh lebih banyak daripada operasi tulis, RwLock dapat lebih baik daripada Mutex. RwLock memungkinkan banyak pembaca secara bersamaan atau satu penulis eksklusif.

Gunakan read untuk akses bersama 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());
}

Pemeriksaan Singkat

Uji pemahaman Anda tentang Arc dan Mutex.

Ringkasan

Anda telah mempelajari bahwa Arc berbagi kepemilikan antarthread dengan penghitungan referensi atomik, tetapi hanya mengizinkan akses yang tidak dapat diubah.

Mutex melindungi mutasi dengan memberikan guard yang dilepaskan saat drop. Gabungkan keduanya sebagai Arc<Mutex<T>> untuk state yang dapat diubah secara bersama-sama, dan waspadai deadlock serta poisoning.

Selanjutnya, Anda akan menggabungkan thread dan mengumpulkan hasilnya.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Berbagi dengan Arc dan Mutex” gratis?

Ya — teks lengkap “Berbagi dengan Arc dan Mutex” 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 “Berbagi dengan Arc dan Mutex”?

Ubah keadaan bersama dengan aman. 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 3 dari 4.

Berapa lama pelajaran “Berbagi dengan Arc dan Mutex” 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