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

Concurrency yang Dapat Dikembangkan dengan Send dan Sync

Menariknya, hampir setiap fitur concurrency yang sudah kita bahas sejauh ini di bab ini merupakan bagian dari standard library, bukan dari bahasa itu sendiri. Pilihan kita untuk menangani concurrency tidak terbatas pada bahasa atau standard library; kita bisa menulis fitur concurrency sendiri atau memakai yang ditulis orang lain.

Namun, beberapa konsep concurrency utama justru tertanam dalam bahasa, bukan di standard library—yaitu trait std::marker Send dan Sync.

Memindahkan Ownership Antar-Thread

Trait marker Send menandakan bahwa ownership atas nilai dari tipe yang mengimplementasikan Send bisa dipindahkan antar-thread. Hampir setiap tipe Rust mengimplementasikan Send, tetapi ada beberapa pengecualian, termasuk Rc<T>: tipe ini tidak bisa mengimplementasikan Send karena jika kamu meng-clone nilai Rc<T> lalu mencoba memindahkan ownership clone itu ke thread lain, kedua thread bisa memperbarui reference count pada saat yang sama. Karena alasan ini, Rc<T> diimplementasikan untuk dipakai dalam situasi single-threaded di mana kamu tidak ingin membayar biaya performa demi thread safety.

Dengan demikian, sistem tipe dan trait bound Rust memastikan kamu tidak pernah bisa mengirim nilai Rc<T> lintas thread secara tidak aman. Saat kita mencoba melakukan ini di Listing 16-14, kita mendapat error the trait `Send` is not implemented for `Rc<Mutex<i32>>`. Saat kita beralih ke Arc<T>, yang memang mengimplementasikan Send, kode tersebut berhasil dikompilasi.

Tipe apa pun yang seluruhnya terdiri dari tipe-tipe Send juga otomatis ditandai sebagai Send. Hampir semua tipe primitif adalah Send, kecuali raw pointer, yang akan kita bahas di Bab 20.

Mengakses dari Beberapa Thread

Trait marker Sync menandakan bahwa aman bagi tipe yang mengimplementasikan Sync untuk di-reference dari beberapa thread. Dengan kata lain, tipe T apa pun mengimplementasikan Sync jika &T (reference immutable ke T) mengimplementasikan Send, yang berarti reference itu bisa dikirim dengan aman ke thread lain. Sama seperti Send, semua tipe primitif mengimplementasikan Sync, dan tipe yang seluruhnya terdiri dari tipe-tipe yang mengimplementasikan Sync juga mengimplementasikan Sync.

Smart pointer Rc<T> juga tidak mengimplementasikan Sync karena alasan yang sama dengan mengapa ia tidak mengimplementasikan Send. Tipe RefCell<T> (yang kita bahas di Bab 15) dan keluarga tipe Cell<T> terkait tidak mengimplementasikan Sync. Implementasi borrow checking yang dilakukan RefCell<T> saat runtime tidaklah thread-safe. Smart pointer Mutex<T> mengimplementasikan Sync dan bisa dipakai untuk berbagi akses dengan beberapa thread, seperti yang kamu lihat di “Akses Bersama ke Mutex<T>”.

Mengimplementasikan Send dan Sync Secara Manual Itu Unsafe

Karena tipe yang seluruhnya terdiri dari tipe-tipe lain yang mengimplementasikan trait Send dan Sync juga otomatis mengimplementasikan Send dan Sync, kita tidak perlu mengimplementasikan trait itu secara manual. Sebagai marker trait, keduanya bahkan tidak punya metode yang perlu diimplementasikan. Keduanya hanya berguna untuk menegakkan invariant yang terkait dengan concurrency.

Mengimplementasikan trait ini secara manual berarti menulis kode Rust unsafe. Kita akan membahas penggunaan kode Rust unsafe di Bab 20; untuk sekarang, yang penting adalah membangun tipe concurrency baru yang tidak tersusun dari bagian-bagian Send dan Sync memerlukan pertimbangan matang untuk menjaga jaminan keamanan. “The Rustonomicon” punya informasi lebih lanjut tentang jaminan ini dan cara menjaganya.

Ringkasan

Ini bukan terakhir kalinya kamu berjumpa dengan concurrency di buku ini: bab berikutnya berfokus pada pemrograman async, dan proyek di Bab 21 akan memakai konsep-konsep dari bab ini dalam situasi yang lebih realistis daripada contoh-contoh kecil yang dibahas di sini.

Seperti yang sudah disebut sebelumnya, karena sangat sedikit dari cara Rust menangani concurrency yang merupakan bagian dari bahasa, banyak solusi concurrency diimplementasikan sebagai crate. Crate-crate ini berkembang lebih cepat daripada standard library, jadi pastikan untuk mencari secara online crate terbaru dan tercanggih yang bisa dipakai dalam situasi multithreaded.

Standard library Rust menyediakan channel untuk message passing dan tipe smart pointer seperti Mutex<T> dan Arc<T> yang aman dipakai dalam konteks concurrency. Sistem tipe dan borrow checker memastikan kode yang memakai solusi-solusi ini tidak akan berujung pada data race atau reference yang tidak valid. Begitu kode kamu berhasil dikompilasi, kamu bisa yakin bahwa kode itu akan berjalan dengan senang di beberapa thread tanpa bug yang sulit dilacak seperti yang umum terjadi di bahasa lain. Pemrograman concurrency bukan lagi konsep yang perlu ditakuti: silakan buat program kamu mendukung concurrency tanpa rasa takut!