Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Rc<T>, the Reference-Counted Smart Pointer

Pada sebagian besar kasus, ownership sudah jelas: kamu tahu persis variabel mana yang memiliki suatu nilai. Namun, ada kalanya sebuah nilai bisa memiliki beberapa pemilik. Misalnya, dalam struktur data graph, beberapa edge bisa menunjuk ke node yang sama, dan secara konseptual node itu dimiliki oleh semua edge yang menunjuknya. Sebuah node seharusnya tidak dibersihkan selama masih ada edge yang menunjuknya, dan dengan demikian masih punya pemilik.

Kamu harus mengaktifkan multiple ownership secara eksplisit dengan memakai tipe Rust Rc<T>, singkatan dari reference counting. Tipe Rc<T> mencatat jumlah reference ke suatu nilai untuk menentukan apakah nilai itu masih digunakan atau tidak. Jika jumlah reference ke sebuah nilai nol, nilai itu bisa dibersihkan tanpa membuat reference mana pun menjadi tidak valid.

Bayangkan Rc<T> sebagai sebuah TV di ruang keluarga. Saat seseorang masuk untuk menonton, mereka menyalakannya. Orang lain bisa masuk ke ruangan dan ikut menonton. Saat orang terakhir meninggalkan ruangan, mereka mematikan TV karena sudah tidak dipakai lagi. Jika seseorang mematikan TV sementara yang lain masih menonton, pasti akan terjadi keributan dari penonton yang tersisa!

Kita memakai tipe Rc<T> saat kita ingin mengalokasikan data di heap agar bisa dibaca oleh beberapa bagian program, dan kita tidak bisa menentukan saat kompilasi bagian mana yang akan selesai menggunakan data itu paling akhir. Jika kita tahu bagian mana yang paling terakhir selesai, kita bisa saja menjadikan bagian itu sebagai pemilik data, dan aturan ownership normal yang ditegakkan saat kompilasi akan berlaku.

Perlu dicatat bahwa Rc<T> hanya untuk dipakai dalam skenario single-threaded. Saat kita membahas concurrency di Bab 16, kita akan membahas cara melakukan reference counting dalam program multithreaded.

Berbagi Data

Mari kembali ke contoh cons list di Listing 15-5. Ingat bahwa kita mendefinisikannya memakai Box<T>. Kali ini, kita akan membuat dua list yang keduanya berbagi ownership atas list ketiga. Secara konseptual, hasilnya mirip dengan Gambar 15-3.

Sebuah linked list dengan label 'a' yang menunjuk ke tiga elemen. Elemen pertama berisi bilangan bulat 5 dan menunjuk ke elemen kedua. Elemen kedua berisi bilangan bulat 10 dan menunjuk ke elemen ketiga. Elemen ketiga berisi nilai 'Nil' yang menandakan akhir dari list; elemen itu tidak menunjuk ke mana pun. Sebuah linked list dengan label 'b' menunjuk ke sebuah elemen yang berisi bilangan bulat 3 dan menunjuk ke elemen pertama dari list 'a'. Sebuah linked list dengan label 'c' menunjuk ke sebuah elemen yang berisi bilangan bulat 4 dan juga menunjuk ke elemen pertama dari list 'a' sehingga ekor dari list 'b' dan 'c' keduanya adalah list 'a'.

Gambar 15-3: Dua list, b dan c, yang berbagi ownership atas list ketiga, a

Kita akan membuat list a yang berisi 5 lalu 10. Setelah itu, kita membuat dua list lagi: b yang dimulai dengan 3 dan c yang dimulai dengan 4. Baik list b maupun c kemudian akan lanjut ke list a pertama yang berisi 5 dan 10. Dengan kata lain, kedua list itu akan berbagi list pertama yang berisi 5 dan 10.

Mencoba menerapkan skenario ini memakai definisi List kita dengan Box<T> tidak akan berhasil, seperti yang ditunjukkan di Listing 15-17.

Filename: src/main.rs
enum List {
    Cons(i32, Box<List>),
    Nil,
}

use crate::List::{Cons, Nil};

fn main() {
    let a = Cons(5, Box::new(Cons(10, Box::new(Nil))));
    let b = Cons(3, Box::new(a));
    let c = Cons(4, Box::new(a));
}
Listing 15-17: Menunjukkan bahwa kita tidak boleh memiliki dua list yang memakai Box<T> dan mencoba berbagi ownership atas list ketiga

Saat kita mengompilasi kode ini, kita mendapat error ini:

$ cargo run
   Compiling cons-list v0.1.0 (file:///projects/cons-list)
error[E0382]: use of moved value: `a`
  --> src/main.rs:11:30
   |
 9 |     let a = Cons(5, Box::new(Cons(10, Box::new(Nil))));
   |         - move occurs because `a` has type `List`, which does not implement the `Copy` trait
10 |     let b = Cons(3, Box::new(a));
   |                              - value moved here
11 |     let c = Cons(4, Box::new(a));
   |                              ^ value used here after move
   |
note: if `List` implemented `Clone`, you could clone the value
  --> src/main.rs:1:1
   |
 1 | enum List {
   | ^^^^^^^^^ consider implementing `Clone` for this type
...
10 |     let b = Cons(3, Box::new(a));
   |                              - you could clone this value

For more information about this error, try `rustc --explain E0382`.
error: could not compile `cons-list` (bin "cons-list") due to 1 previous error

Varian Cons memiliki data yang mereka simpan, jadi saat kita membuat list b, a dipindahkan ke dalam b dan b memiliki a. Lalu, saat kita mencoba memakai a lagi ketika membuat c, kita tidak diizinkan karena a sudah dipindahkan.

Kita bisa mengubah definisi Cons agar menyimpan reference sebagai gantinya, tetapi saat itu kita harus menentukan parameter lifetime. Dengan menentukan parameter lifetime, kita menyatakan bahwa setiap elemen dalam list akan hidup setidaknya selama list itu sendiri. Hal itu memang berlaku untuk elemen dan list di Listing 15-17, tetapi tidak untuk setiap skenario.

Sebagai gantinya, kita akan mengubah definisi List untuk memakai Rc<T> sebagai pengganti Box<T>, seperti yang ditunjukkan di Listing 15-18. Sekarang, setiap varian Cons akan menyimpan sebuah nilai dan sebuah Rc<T> yang menunjuk ke sebuah List. Saat kita membuat b, alih-alih mengambil ownership atas a, kita akan meng-clone Rc<List> yang dipegang a, sehingga jumlah reference naik dari satu menjadi dua dan a serta b berbagi ownership atas data di Rc<List> itu. Kita juga akan meng-clone a saat membuat c, menaikkan jumlah reference dari dua menjadi tiga. Setiap kali kita memanggil Rc::clone, jumlah reference ke data di dalam Rc<List> bertambah, dan data itu tidak akan dibersihkan selama masih ada reference ke sana.

Filename: src/main.rs
enum List {
    Cons(i32, Rc<List>),
    Nil,
}

use crate::List::{Cons, Nil};
use std::rc::Rc;

fn main() {
    let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
    let b = Cons(3, Rc::clone(&a));
    let c = Cons(4, Rc::clone(&a));
}
Listing 15-18: Definisi List yang memakai Rc<T>

Kita perlu menambahkan statement use untuk membawa Rc<T> ke dalam scope karena tipe itu tidak ada di prelude. Di main, kita membuat list yang berisi 5 dan 10, lalu menyimpannya dalam Rc<List> baru di a. Setelah itu, saat membuat b dan c, kita memanggil fungsi Rc::clone dan memberikan reference ke Rc<List> di a sebagai argumen.

Kita bisa saja memanggil a.clone() alih-alih Rc::clone(&a), tetapi kebiasaan di Rust adalah memakai Rc::clone dalam kasus ini. Implementasi Rc::clone tidak membuat salinan mendalam dari seluruh data seperti yang dilakukan implementasi clone pada kebanyakan tipe. Panggilan ke Rc::clone hanya menambah jumlah reference, yang tidak memakan banyak waktu. Sementara itu, salinan mendalam bisa memakan waktu lama. Dengan memakai Rc::clone untuk reference counting, kita bisa membedakan secara visual antara clone yang menyalin mendalam dan clone yang hanya menambah jumlah reference. Saat mencari masalah performa dalam kode, kita hanya perlu memeriksa clone yang menyalin mendalam dan bisa mengabaikan panggilan ke Rc::clone.

Meng-clone untuk Menambah Jumlah Reference

Mari ubah contoh yang sedang kita kerjakan di Listing 15-18 agar kita bisa melihat jumlah reference berubah saat kita membuat dan membuang reference ke Rc<List> di a.

Di Listing 15-19, kita akan mengubah main agar punya scope di dalamnya di sekitar list c; dengan begitu, kita bisa melihat bagaimana jumlah reference berubah saat c keluar dari scope.

Filename: src/main.rs
enum List {
    Cons(i32, Rc<List>),
    Nil,
}

use crate::List::{Cons, Nil};
use std::rc::Rc;

// --snip--

fn main() {
    let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
    println!("count after creating a = {}", Rc::strong_count(&a));
    let b = Cons(3, Rc::clone(&a));
    println!("count after creating b = {}", Rc::strong_count(&a));
    {
        let c = Cons(4, Rc::clone(&a));
        println!("count after creating c = {}", Rc::strong_count(&a));
    }
    println!("count after c goes out of scope = {}", Rc::strong_count(&a));
}
Listing 15-19: Mencetak jumlah reference

Di setiap titik dalam program saat jumlah reference berubah, kita mencetak jumlah itu, yang kita dapat dengan memanggil fungsi Rc::strong_count. Fungsi ini dinamai strong_count, bukan count, karena tipe Rc<T> juga punya weak_count; kita akan melihat kegunaan weak_count di “Mencegah Reference Cycle Memakai Weak<T>”.

Kode ini mencetak hal berikut:

$ cargo run
   Compiling cons-list v0.1.0 (file:///projects/cons-list)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.45s
     Running `target/debug/cons-list`
count after creating a = 1
count after creating b = 2
count after creating c = 3
count after c goes out of scope = 2

Kita bisa melihat bahwa Rc<List> di a awalnya memiliki jumlah reference 1; lalu, setiap kali kita memanggil clone, jumlahnya naik 1. Saat c keluar dari scope, jumlahnya turun 1. Kita tidak perlu memanggil fungsi untuk menurunkan jumlah reference seperti halnya kita harus memanggil Rc::clone untuk menaikkannya: implementasi trait Drop menurunkan jumlah reference secara otomatis saat nilai Rc<T> keluar dari scope.

Yang tidak bisa kita lihat dalam contoh ini adalah saat b lalu a keluar dari scope di akhir main, jumlahnya menjadi 0, dan Rc<List> dibersihkan sepenuhnya. Memakai Rc<T> memungkinkan sebuah nilai memiliki beberapa pemilik, dan jumlah itu memastikan nilai tetap valid selama salah satu pemiliknya masih ada.

Melalui immutable reference, Rc<T> memungkinkan kamu berbagi data antar beberapa bagian program untuk dibaca saja. Jika Rc<T> juga mengizinkan kamu memiliki beberapa mutable reference, kamu bisa melanggar salah satu aturan borrowing yang dibahas di Bab 4: Beberapa mutable borrow ke tempat yang sama bisa menyebabkan data race dan inkonsistensi. Tetapi kemampuan mengubah data itu sangat berguna! Di bagian berikutnya, kita akan membahas pola interior mutability dan tipe RefCell<T> yang bisa kamu pakai bersama Rc<T> untuk mengatasi batasan immutability ini.