Penunjuk Cerdas Box, Rc, dan Arc
Pahami cara `Box` untuk alokasi heap, `Rc` untuk kepemilikan bersama, dan `Arc` untuk kepemilikan bersama yang aman bagi thread mengelola data.
Penunjuk Cerdas Box, Rc, dan Arc adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 1 dari 3. 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 3 pelajaran total.
Apa Itu Penunjuk Pintar?
Sistem kepemilikan Rust sangat baik untuk keamanan memori, tetapi terkadang Anda memerlukan fleksibilitas yang lebih besar. Di sinilah penunjuk pintar berperan!
Penunjuk pintar adalah struktur data yang bertindak seperti penunjuk, tetapi juga memiliki metadata dan kemampuan tambahan. Penunjuk ini mengelola memori, kepemilikan, dan sumber daya lainnya secara otomatis.
Box: Menyimpan Data di Heap
Penunjuk pintar paling sederhana adalah Box<T>. Penunjuk ini memungkinkan Anda menyimpan data di heap, bukan di stack.
- Stack: Data berukuran tetap yang cepat.
- Heap: Data berukuran fleksibel yang lebih lambat dan dialokasikan saat waktu berjalan.
Ketika Anda memasukkan suatu nilai ke dalam Box, Box itu sendiri berada di stack, tetapi data yang ditunjuknya berada di heap.
Menggunakan Box untuk Alokasi Heap
Mari kita lihat bagaimana Box memindahkan data ke heap. Ini berguna untuk data berukuran besar atau ketika Anda tidak mengetahui ukurannya saat kompilasi.
Jalankan kode ini untuk mengamati suatu nilai yang dimasukkan ke dalam Box.
fn main() {
let x = 5; // x is on the stack
let boxed_x = Box::new(x); // x's value is moved to the heap, boxed_x is on stack
println!("Value on stack: {}", x);
println!("Value in Box (on heap): {}", *boxed_x); // Dereference to get value
}Kapan Box Berguna
Anda mungkin menggunakan Box<T> dalam situasi berikut:
- Ketika Anda memiliki tipe yang ukurannya tidak dapat diketahui saat kompilasi, dan Anda perlu menyimpannya di tempat dengan ukuran yang diketahui dan tetap.
- Ketika Anda memiliki data dalam jumlah besar dan ingin memindahkan kepemilikan tanpa menyalin datanya.
- Ketika Anda ingin memiliki objek sifat (misalnya,
Box<dyn Trait>).
Rc: Beberapa Pemilik (Satu Utas)
Aturan kepemilikan Rust berarti suatu nilai biasanya hanya memiliki satu pemilik. Namun, bagaimana jika beberapa bagian program Anda perlu "memiliki" data yang sama?
Rc<T>, atau Reference Counted, memungkinkan beberapa pemilik data dalam situasi satu utas. Penunjuk ini melacak jumlah referensi yang menunjuk ke data tersebut.
Ketika jumlahnya turun menjadi nol, data akan dibersihkan.
Berbagi Data dengan Rc
Rc::clone() menambah jumlah referensi. Ini bukan penyalinan mendalam; tindakan ini hanya membuat penunjuk lain ke data yang sama.
Perhatikan bahwa data tersebut dibagikan, dan nilainya dapat diakses dari "pemilik" yang berbeda.
use std::rc::Rc;
fn main() {
let value = Rc::new(String::from("Shared String"));
println!("Count after creation: {}", Rc::strong_count(&value));
let value_clone_a = Rc::clone(&value); // Increment count
println!("Count after clone A: {}", Rc::strong_count(&value));
{
let value_clone_b = Rc::clone(&value); // Increment count
println!("Count after clone B: {}", Rc::strong_count(&value));
println!("Data from A: {}", value_clone_a);
println!("Data from B: {}", value_clone_b);
} // value_clone_b goes out of scope, count decreases
println!("Count after B goes out of scope: {}", Rc::strong_count(&value));
}Arc: Kepemilikan Bersama (Banyak Utas)
Rc<T> bekerja dengan baik untuk aplikasi satu utas. Namun, jika Anda perlu berbagi data di antara beberapa utas, Rc<T> tidak aman.
Arc<T>, atau Atomic Reference Counted, adalah versi Rc<T> yang aman untuk utas. Penunjuk ini menggunakan operasi atomik untuk memperbarui jumlah referensi, sehingga menjamin keamanan di seluruh utas.
Arc memiliki sedikit beban kinerja dibandingkan Rc karena adanya operasi atomik.
Berbagi Data Antar-Utas dengan Arc
Contoh ini menunjukkan cara Arc memungkinkan beberapa utas mengakses dan membaca data bersama yang sama dengan aman. Setiap utas mendapatkan klon `Arc`-nya sendiri.
Utas utama menunggu semua utas yang dibuat selesai.
use std::sync::Arc;
use std::thread;
fn main() {
let data = Arc::new(vec![1, 2, 3, 4, 5]);
let mut handles = vec![];
for i in 0..3 {
let data_clone = Arc::clone(&data); // Clone Arc for each thread
let handle = thread::spawn(move || {
println!("Thread {} has data: {:?}", i, *data_clone);
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
println!("All threads finished.");
}Box, Rc, atau Arc?
Pemilihan penunjuk pintar yang tepat bergantung pada kebutuhan Anda:
Box<T>: Saat Anda perlu menempatkan data di heap, biasanya untuk kepemilikan tunggal atau saat menangani tipe rekursif.Rc<T>: Saat Anda memerlukan beberapa pemilik data dalam konteks satu utas.Arc<T>: Saat Anda memerlukan beberapa pemilik data dalam konteks banyak utas (konkuren).
Selalu pilih Box atau Rc jika Anda tidak memerlukan keamanan utas, karena Arc memiliki biaya kinerja.
Pemeriksaan Penunjuk Pintar
Anda perlu menyimpan berkas gambar berukuran besar di heap, dan hanya satu bagian program Anda yang akan memiliki serta mengelolanya. Penunjuk pintar mana yang sebaiknya Anda gunakan?
Rangkuman: Penunjuk Pintar
Dalam pelajaran ini, Anda telah mempelajari tiga penunjuk pintar Rust yang mendasar:
Box<T>: Untuk mengalokasikan data di heap dengan kepemilikan tunggal.Rc<T>: Untuk memungkinkan beberapa pemilik data dalam lingkungan satu utas.Arc<T>: Untuk memungkinkan beberapa pemilik data yang aman untuk utas dalam lingkungan banyak utas.
Penunjuk pintar ini memberi Anda lebih banyak kendali atas pengelolaan memori sambil tetap memanfaatkan jaminan keamanan Rust.
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Penunjuk Cerdas Box, Rc, dan Arc” gratis?
Ya — teks lengkap “Penunjuk Cerdas Box, Rc, dan Arc” 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 3 pelajaran total.
Apa yang akan aku pelajari di “Penunjuk Cerdas Box, Rc, dan Arc”?
Pahami cara `Box` untuk alokasi heap, `Rc` untuk kepemilikan bersama, dan `Arc` untuk kepemilikan bersama yang aman bagi thread mengelola data. 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 3.
Berapa lama pelajaran “Penunjuk Cerdas Box, Rc, dan Arc” 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
- Penunjuk Cerdas Box, Rc, dan Arc
- Mutabilitas Internal: RefCell, Cell
- Konkurensi Tanpa Rasa Takut dengan Thread