Tutorial Rust: Keamanan Memori dan Konkurensi

Rust telah menjadi salah satu bahasa pemrograman yang Setiap pengembang sistem akhirnya mendengarnya berulang-ulang.Secepat C dan C++, tetapi dengan fokus yang nyaris obsesif pada keamanan memori dan konkurensi yang tereksekusi dengan baik. Ini bukan sekadar pemasaran kosong: desainnya berpusat pada kompilator yang mendeteksi kesalahan pada waktu kompilasi—kesalahan yang dalam bahasa pemrograman lain hanya terlihat ketika sistem sudah dalam tahap produksi… atau ketika mengalami crash.

Jika Anda tertarik untuk memahami Bagaimana Rust mencapai memori aman tanpa pengumpulan sampah dan konkurensi tanpa takut data berjalanTutorial ini untuk Anda. Kami akan membahas semuanya, mulai dari dasar-dasar bahasa dan ekosistemnya hingga konsep-konsep kunci seperti kepemilikan, peminjaman, tipe gabungan, alat seperti Cargo, dan bahkan membahas tipe atomik dan penguncian dari perspektif yang lebih mudah dipahami bagi mereka yang baru mengenal konkurensi, semuanya dengan fokus pada keamanan dan performa.

Tutorial Rust: Performa, Keamanan Memori, dan Konkurensi

Rust adalah bahasa pemrograman pemrograman tujuan umum dan multi-paradigma, dirancang untuk pemrograman sistem tingkat rendah serta untuk proyek tingkat tinggidari sistem operasiDari mesin permainan dan peramban hingga layanan web berkinerja tinggi, semuanya berasal dari Mozilla dengan tujuan meningkatkan keamanan perangkat lunak, terutama pada komponen sensitif seperti mesin peramban.

Karakteristik yang menentukannya adalah menjamin keamanan memori pada waktu kompilasi tanpa menggunakan pengumpul sampah. Sebaliknya, Rust menggunakan sistem kepemilikan dan pemeriksa peminjaman yang melacak masa pakai setiap nilai dan referensinya. Hal ini menghindari masalah klasik seperti pointer yang menggantung, buffer overflow, atau kebocoran memori tanpa memerlukan penghitungan referensi otomatis atau pengumpulan sampah.

Selain itu, Rust dirancang untuk membuatnya lebih mudah konkurensi amanTipe dan model kepemilikannya mencegah perlombaan data antar-utas, setidaknya sambil tetap menjaga kode Rust tetap aman. Ini berarti banyak situasi berbahaya terdeteksi pada waktu kompilasi, sebelum satu baris pun dieksekusi.

Karena semua alasan ini, perusahaan besar seperti Dropbox, Microsoft, Amazon atau Google Mereka telah mengadopsi Rust di bagian-bagian penting infrastruktur mereka. Dan bukan kebetulan bahwa Rust telah menduduki puncak jajak pendapat Stack Overflow selama bertahun-tahun sebagai salah satu bahasa pemrograman "paling dicintai" oleh para pengembang: ia menggabungkan performa ala C++ dengan perangkat modern (Cargo, crates.io) dan komunitas yang sangat aktif, yang disebut Rustaceans.

Konsep dasar: bahasa pemrograman, jenis dan memori

Sebelum membahas secara spesifik tentang keamanan memori dan konkurensi, ada baiknya untuk mengklarifikasi beberapa konsep umum yang muncul di seluruh el tiempo Saat bekerja dengan Rust, terutama jika Anda berasal dari bahasa lain atau baru memulai pemrograman.

Bahasa pemrograman pada dasarnya adalah seperangkat aturan dan struktur yang memungkinkan Anda mendeskripsikan algoritma dan mengubahnya menjadi program yang dapat dieksekusi. Rust mengompilasi menjadi kode mesin asli menggunakan kompilernya rustcOleh karena itu, kinerja yang Anda dapatkan biasanya setara dengan C dan C++.

Manajemen memori adalah proses dimana sebuah program menyimpan dan melepaskan blok memori saat berjalanKesalahan di area ini seringkali berakibat fatal: kebocoran memori (gagal melepaskan memori yang tidak terpakai), kerusakan data akibat penulisan di luar batas, atau penggunaan memori setelah dibebaskan. Rust mengatasi hal ini dengan sistem tipe yang sangat kuat dan aturan formal untuk kepemilikan, peminjaman, dan masa hidup.

Karat juga memiliki istilah seperti tipe dan petunjuk cerdasTipe menggambarkan jenis data yang disimpan oleh suatu variabel (bilangan bulat, bilangan float, string, struktur, dll.) dan bagaimana data tersebut dapat dimanipulasi. Pointer pintar (misalnya, Box, Rc y Arc) adalah struktur yang merangkum alamat memori dan menambahkan logika tambahan untuk mengelola sumber daya dengan aman, seperti menghitung referensi bersama atau memindahkan nilai ke tumpukan.

Dalam bidang persaingan, konsep seperti kondisi balapan, mutex, dan saluran Mereka menjadi sangat penting: kondisi balapan terjadi saat beberapa utas mengakses dan memodifikasi sumber daya bersama secara bersamaan tanpa koordinasi yang tepat; mutex (pengecualian bersama) memastikan bahwa hanya satu utas yang memasuki bagian kritis pada satu waktu; dan saluran memungkinkan pesan dikirim antara utas tanpa berbagi memori secara langsung.

Mengapa mempelajari Rust: Keamanan memori dan konkurensi yang tak kenal takut

Karat telah mendapatkan ketenarannya karena menawarkan tiga pilar yang sangat berharga untuk pemrograman modernPerforma, keamanan, dan perangkat terkini. Mari kita lihat mengapa poin-poin ini begitu relevan.

Mengenai kinerja, Rust dikompilasi langsung ke biner asli tanpa memerlukan mesin virtual atau interpreter. Model abstraksi tanpa biaya bertujuan untuk memastikan bahwa abstraksi tingkat tinggi tidak menambah overhead saat runtime. Oleh karena itu, model ini ideal untuk pengembangan sistem. permainan, komponen browser, atau layanan mikro latensi rendah.

Keamanan memori didasarkan pada sistem kepemilikan dan pinjamanTidak ada pengumpul sampah, tetapi kompiler tahu persis siapa yang memiliki setiap sumber daya, kapan tidak lagi dibutuhkan, dan kapan dapat dilepaskan. Hal ini mencegah kebocoran, pointer yang menggantung, dan banyak kesalahan yang secara tradisional membuat pemrograman C dan C++ begitu berbahaya.

Di bidang persaingan, Rust mengejar apa yang biasa disebut “konkurensi tanpa rasa takut”Sistem tipe itu sendiri mencegah akar data ada dalam kode yang aman. Jika Anda ingin berbagi data yang dapat diubah antar thread, Anda perlu menggunakan primitif yang sesuai seperti Mutex, RwLock o Arc, dan kompilator akan memastikan bahwa aturan aliasing dan mutabilitas dihormati.

Pengalaman pengembangan ditingkatkan dengan alat-alat modern seperti MuatanPlatform ini dilengkapi dengan pengelola paket dan infrastruktur build terintegrasi, serta ekosistem pustaka (crate) yang luas yang mencakup segala hal mulai dari jaringan asinkron (Tokyo) hingga kerangka kerja web (Actix, Rocket, Axum). Semua ini didukung oleh komunitas yang terbuka, produktif, dan cukup sabar, terutama bagi para pemula.

Instalasi dan alat penting: rustup, rustc dan Cargo

Untuk menulis dan menjalankan program pertama Anda di Rust, cara yang biasa untuk memulai adalah dengan menginstal toolchain resmi menggunakan karat (lihat Pengantar lengkap tentang Rust), penginstal dan pengelola versi sederhana yang berfungsi pada semua sistem operasi utama.

dengan karat Anda dapat menginstal, memperbarui, dan beralih di antara berbagai versi Rust (stabil, beta, nightly) tanpa mengalami masalah apa pun. Cukup kunjungi halaman alat Rust resmi dan ikuti langkah-langkahnya untuk sistem Anda. Setelah terinstal, kompiler akan tersedia. rustc, manajer proyek cargo dan miliknya sendiri rustup di Anda terminal.

penyusun rustc Inilah yang mengubah kode sumber Anda menjadi biner atau pustaka yang dapat dieksekusi. Meskipun Anda dapat memanggilnya langsung dengan perintah sebagai rustc main.rsDalam praktiknya, Anda hampir selalu bekerja melalui Cargo, yang menangani panggilan ke rustc dengan pilihan yang tepat.

Alat utama alur kerja adalah MuatanHanya dengan beberapa perintah, Anda dapat membuat proyek baru, mengelola dependensi, mengompilasi, menjalankan, menguji, dan menerbitkan paket di crates.io. Beberapa perintah dasar yang umum digunakan adalah: cargo new, cargo build, cargo run, cargo test y cargo check, yang memeriksa kode tanpa menghasilkan eksekusi akhir, ideal untuk mendeteksi kesalahan dengan cepat.

Jika Anda ingin mengotak-atik tanpa menginstal apa pun, Taman Bermain Karat (pelaksana daring resmi) dan platform seperti Replit memungkinkan Anda menulis dan menjalankan potongan kode kecil dari peramban, cocok untuk bereksperimen dengan contoh memori dan konkurensi tanpa harus menyiapkan seluruh lingkungan.

Program pertama Anda: Halo, Rust, dan aliran dasar

Cara klasik untuk memulai percakapan dalam bahasa apa pun adalah dengan "Halo, dunia" yang terkenal. Di Rust, file main.rs setidaknya bisa berisi sesuatu yang sederhana seperti fungsi main yang mencetak string di layar.

Kata kuncinya fn menunjukkan bahwa kita mendefinisikan suatu fungsi, dan main Ini adalah titik masuk program. Blok kode fungsi berada di dalam kurung kurawal. Untuk menulis ke konsol, gunakan makro println!, yang menerima string literal (atau templat dengan penanda) dan mengirimkannya ke keluaran standar yang diakhiri dengan karakter baris baru.

Jika Anda mengkompilasi langsung dengan rustc main.rs, Anda akan mendapatkan biner yang dapat dieksekusi (misalnya, main o main.exe (tergantung sistemnya). Saat Anda menjalankannya, Anda akan melihat pesan di terminal. Namun, cara idiomatis untuk bekerja dengan Rust adalah dengan membiarkan Cargo memimpin proyek tersebut.

dengan cargo new nombre_proyecto Struktur folder dibuat secara otomatis dengan src/main.rs sudah disiapkan dengan "Halo, dunia" dan file Cargo.toml yang berisi metadata dan dependensi di masa mendatang. Dari sana, cargo run kompilasi dan jalankan binernyadan hanya mengkompilasi ulang ketika mendeteksi perubahan.

Cara kerja ini tidak hanya nyaman, tetapi juga membuat Anda terbiasa menggunakan ekosistem Rust standar sejak awal, yang sangat berguna saat Anda mulai menambahkan peti untuk konkurensi, jaringan, pengujian, atau apa pun yang Anda butuhkan.

// Kami mendeklarasikan fungsi utama: titik masuk program fn main() { // Kami menggunakan makro println! untuk mencetak teks ke konsol println!("Halo, dunia!"); }

Variabel, mutabilitas, dan tipe data dasar

Dalam Rust, variabel dideklarasikan dengan kata kunci let, dan secara default tidak dapat diubahDengan kata lain, setelah Anda menetapkan nilai kepada mereka, Anda tidak dapat mengubahnya kecuali Anda secara eksplisit mendeklarasikannya sebagai sesuatu yang dapat diubah dengan mut.

Kekekalan secara default membantu menghindari kesalahan logika yang halus, terutama dalam program bersamaan di mana beberapa utas mungkin ingin mengubah nilai yang sama. Jika Anda perlu mengubahnya, tuliskan sesuatu seperti let mut contador = 0;Dari sana Anda dapat menetapkan kembali nilai baru ke contador.

Karat juga memungkinkan apa yang disebut pembayanganAnda dapat mendeklarasikan variabel baru dengan nama yang sama dalam lingkup yang sama, menyembunyikan variabel sebelumnya. Ini tidak sama dengan mutasi, karena Anda menciptakan nilai baru (yang bahkan bisa bertipe berbeda). Misalnya, Anda dapat mengonversi string menjadi integer menggunakan nama yang sama, asalkan deklarasi tersebut merupakan deklarasi baru dengan let.

Sistem tipe Rust bersifat statis, yang berarti bahwa Tipe setiap variabel diketahui saat kompilasiNamun, inferensi tipe cukup kuat: jika Anda menulis let x = 5;Kompiler berasumsi bahwa itu adalah i32 Kecuali jika Anda memberi tahu sebaliknya. Anda dapat menambahkan catatan seperti let x: i64 = 5; ketika Anda ingin bersikap eksplisit.

Di antara tipe skalar yang tersedia adalah bilangan bulat bertanda dan tak bertanda (i8, u8, i32, dll), yang mengambang (f32, f64), Boolean (bool) dan karakter Unicode (char). Tipe sederhana ini biasanya murah untuk ditiru dan banyak yang menerapkan sifat tersebut Copyyang berarti bahwa saat Anda menetapkan atau meneruskannya ke suatu fungsi, file tersebut akan disalin, bukan dipindahkan.

String di Rust: &str dan String

Penanganan teks di Rust mungkin sedikit membingungkan pada awalnya karena secara jelas membedakan antara “irisan” rantai dan rantai kepemilikanDua bagian kunci adalah &str y String.

Un &str adalah sepotong rantai yang tidak dapat diubahTampilan urutan byte UTF-8 yang disimpan di suatu tempat. Contoh umum termasuk literal seperti "Hola"yang termasuk jenis &'static str (Mereka ada sepanjang umur program dan tertanam dalam biner.) Irisan tidak memiliki data; mereka hanya menunjuk ke sana.

String, di sisi lain, adalah string sendiri, bisa diubah dan dihosting di tumpukanIa dapat diubah ukurannya, dirangkai, diteruskan antar fungsi dengan memindahkan propertinya, dsb. Ia sering digunakan ketika Anda ingin membuat teks dinamis atau menyimpannya dalam jangka panjang dalam suatu struktur.

Dalam banyak skenario Anda akan bertransformasi antara satu dan yang lain: misalnya, Anda akan membuat String::from("hola") dari sepotongatau kamu akan meminjam &str sebuah String dengan meneruskan referensi ke fungsi yang hanya perlu membaca.

Pemisahan antara data yang dimiliki dan yang dipinjam merupakan kunci manajemen memori dan berlaku juga pada seluruh bahasa pemrograman: koleksi, struktur, dan enum mengikuti ide yang sama tentang siapa yang memiliki dan siapa yang hanya melihat.

Fungsi, alur kontrol, dan komentar

Fungsi dalam Rust didefinisikan dengan fn dan memungkinkan program untuk diorganisasikan ke dalam unit logis yang dapat digunakan kembali. Setiap fungsi menentukan jenis parameternya dan tipe pengembaliannya mengikuti anak panah ->Jika tidak menghasilkan sesuatu yang berarti, tipe kesatuan diasumsikan. ().

Detail penting adalah bahwa ekspresi terakhir dalam suatu fungsi (atau blok apa pun) tanpa titik koma dianggap sebagai nilai balik implisit. Anda dapat menggunakan return untuk pengembalian awalNamun dalam kode idiomatik, Anda sering kali membiarkan ekspresi akhir begitu saja. ;.

Aliran kontrol ditangani dengan klasik if/elselingkaran loop, while y forDalam Karat, if Ini adalah ekspresi yang mengembalikan nilaisehingga Anda dapat menggunakannya secara langsung di letasalkan cabang-cabangnya mengembalikan tipe yang sama. for Mereka biasanya mengulangi rentang atau iterator koleksi dan merupakan opsi yang direkomendasikan sebagai pengganti indeks manual.

Untuk mendokumentasikan kode dan membuat hidup lebih mudah bagi siapa pun yang datang setelahnya (termasuk Anda sendiri dalam sebulan), Anda dapat menggunakan komentar baris dengan // atau blok dengan /* ... */Selain itu, Rust menawarkan komentar dokumentasi dengan /// yang menjadi dokumen yang dihasilkan, meskipun itu lebih cocok untuk proyek besar.

Kepemilikan, peminjaman, dan masa hidup: fondasi keamanan memori

Di sini kita sampai pada inti model memori Rust: sistem kepemilikan, pinjaman, dan masa hidupAturan-aturan ini memastikan bahwa referensi selalu valid dan bahwa memori dilepaskan dengan aman tanpa akumulasi sampah.

Aturan dasar kepemilikan mudah untuk dinyatakan, meskipun mungkin sulit untuk dipahami pada awalnya: Tiap nilai memiliki satu pemilik.Hanya boleh ada satu pemilik pada satu waktu; dan ketika pemilik meninggalkan ruang lingkupnya, nilainya akan dihancurkan dan memorinya dilepaskan. Hal ini berlaku, misalnya, untuk String: setelah selesainya blok tempat ia dideklarasikan, ia secara otomatis dipanggil drop yang membebaskan memori tumpukan.

Ketika Anda menetapkan nilai yang tepat ke variabel lain atau meneruskannya berdasarkan nilai ke suatu fungsi, properti tersebut akan dipindahkan. Ini berarti variabel asli tidak lagi berlaku setelah pemindahanSemantik pergerakan ini menghindari rilis ganda, karena tidak pernah ada dua pemilik yang mencoba merilis sumber daya yang sama.

Agar beberapa bagian program dapat mengakses nilai yang sama tanpa mengubah kepemilikan, Rust memperkenalkan referensi dan peminjaman. Saat Anda meminjam, Anda membuat referensi &T (tidak dapat diubah) atau &mut T (dapat berubah) terhadap nilai tanpa mentransfer kepemilikan. Pinjaman dibatasi oleh aturan pemverifikasi pinjaman., yang memeriksa bahwa referensi tidak bertahan lebih lama dari data yang ditunjuknya dan bahwa akses yang dapat diubah dan akses bersama tidak tercampur secara berbahaya.

Aturan pinjaman dapat diringkas sebagai berikut: kapan saja, Anda dapat memiliki beberapa referensi yang tidak dapat diubah ke suatu nilai, atau satu referensi yang dapat diubahNamun, tidak keduanya sekaligus. Hal ini menghilangkan kondisi persaingan dalam memori bersama: terdapat banyak pembaca, atau terdapat penulis yang terisolasi; tidak pernah ada pembaca dan penulis simultan pada data yang sama pada saat yang bersamaan.

Tipe komposit: struct, enum, dan smart pointer

Rust menyediakan beberapa cara untuk mengelompokkan data terkait ke dalam struktur yang lebih kaya, dimulai dengan strukturSuatu struct memungkinkan Anda menentukan tipe khusus dengan bidang-bidang bernama, misalnya pengguna dengan email, nama, status aktivitas, dan penghitung login.

Untuk membuat instans struct, Anda harus mengisi semua kolomnya, dan Anda dapat menandai variabel yang memuatnya sebagai variabel yang dapat diubah untuk mengubah nilainya nanti. Terdapat juga sintaks pembaruan struct, yang memungkinkan Anda membuat instans baru dengan menggunakan kembali beberapa kolom dari instans yang sudah ada. ..otro_struct.

Los enum Mereka adalah pilar penting lainnya: mereka memungkinkan Anda menentukan tipe yang bisa berupa salah satu dari beberapa varian yang mungkin, masing-masing dengan atau tanpa data terkaitnya sendiri. Contoh klasiknya adalah enum untuk alamat IP, dengan satu varian V4 yang menyimpan empat oktet dan satu lagi V6 yang menyimpan string dengan notasi IPv6.

Pustaka standar Rust mencakup dua enum yang sangat penting: Option<T> y Result<T, E>Yang pertama mewakili keberadaan atau ketiadaan suatu nilai (sesuatu atau tidak sama sekali), dan digunakan untuk menghindari pointer null; yang kedua memodelkan operasi yang dapat mengembalikan hasil yang benar atau kesalahan, yang mengharuskan penanganan kesalahan bersifat eksplisit dan aman.

Untuk mengelola memori dinamis dan berbagi data, Rust memiliki petunjuk cerdas sebagai Box<T>, yang memindahkan nilai ke tumpukan dan mempertahankan kepemilikan yang unik; Rc<T>, jumlah referensi bersama untuk lingkungan berulir tunggal; dan Arc<T>mirip dengan Rc tetapi aman untuk beberapa utas. Penggunaannya yang tepat sangat penting saat menggabungkan memori dinamis dengan konkurensi.

Kargo dan Ekosistem Peti

Kargo adalah perekat yang menyatukan ekosistem Rust: mengelola kompilasi, dependensi, dan siklus hidup proyekSetiap proyek memiliki file Cargo.toml yang berfungsi sebagai manifes, yang mendeklarasikan nama, versi, edisi bahasa, dan dependensi eksternal.

Bagian Berkas ini memungkinkan Anda untuk membuat daftar peti pihak ketiga beserta versinya. Saat Anda menjalankan cargo build o cargo runCargo secara otomatis mengunduh peti-peti ini dari crates.io, mengompilasinya, dan menautkannya ke proyek Anda. Semudah itu untuk menambahkan, misalnya, generator angka acak, kerangka kerja web, atau pustaka kriptografi.

Di antara perintah yang paling umum adalah cargo new untuk memulai proyek biner o cargo new --lib untuk perpustakaan; cargo build untuk mengkompilasi dalam mode debug; cargo build --release untuk mendapatkan versi yang dioptimalkan dan berorientasi produksi; dan cargo test untuk menjalankan serangkaian pengujian.

cargo check Hal ini layak disebutkan secara khusus: ia mengkompilasi kode ke titik perantara tanpa menghasilkan biner, yang membuatnya sangat cepat dalam mendeteksi kesalahan kompilasiSempurna untuk mengulang dengan cepat sementara pemeriksa peminjaman menunjukkan masalah dengan properti, referensi, dan masa hidup.

Berkat ekosistem ini, proyek Anda biasanya disusun dalam peti-peti kecil yang terdefinisi dengan baik, berbagi kode di antara mereka, dan menggunakan kembali solusi yang dibuat oleh komunitas. Untuk konkurensi tingkat lanjut, misalnya, Anda akan memiliki peti seperti Tokio untuk pemrograman asinkron atau crossbeam untuk struktur data konkuren berkinerja tinggi.

Konkurensi dalam Rust: thread, mutex, saluran, dan atomics

Konkurensi adalah salah satu alasan mengapa Rust menarik begitu banyak minat: ia memungkinkan Anda memanfaatkan prosesor multi-inti. tanpa jatuh ke dalam kesalahan umum benang dan memori bersamaJika ini pertama kalinya Anda mempelajari topik ini, ada baiknya Anda membedakan beberapa konsep.

Konkurensi melibatkan eksekusi beberapa tugas yang tumpang tindih dalam waktu, baik pada satu atau beberapa inti. Di Rust, Anda dapat membuat thread sistem untuk melakukan pekerjaan secara paralel, dan bahasa pemrograman ini memandu Anda untuk memastikan keamanan berbagi data di antara mereka. Kesalahan klasik adalah kondisi balapan, di mana dua thread mengakses dan memodifikasi data secara bersamaan, dan hasilnya bergantung pada urutan eksekusi—sesuatu yang sangat sulit untuk di-debug.

Untuk mengoordinasikan akses ke data bersama, Rust bergantung pada primitif seperti mutexyang menjamin pengecualian bersama: hanya satu utas yang dapat memasuki bagian kritis pada satu waktu. Dikombinasikan dengan Arc<T> Untuk berbagi kepemilikan antar-utas, dimungkinkan untuk membangun struktur data bersama yang mematuhi aturan kepemilikan dan peminjaman.

Bentuk umum lain dari komunikasi antar-utas, yang sangat dianjurkan dalam Rust, adalah penyampaian pesan menggunakan saluranSaluran memiliki ujung pengirim dan ujung penerima; utas meneruskan pesan (nilai) melaluinya, yang mengurangi penggunaan memori bersama yang dapat diubah dan menyederhanakan penalaran tentang status sistem.

Bila Anda menyelidiki lebih dalam pada konkurensi tingkat rendah, hal berikut akan muncul: jenis atomVariabel atomik diakses melalui operasi yang tidak dapat dipisahkan dari perspektif thread. Hal ini memungkinkan implementasi penghitung bersama, tanda status, antrean bebas kunci, dan banyak lagi. Menguasai variabel atomik membutuhkan pemahaman tentang model memori dan perintah akses, sehingga banyak pengembang lebih suka memulai dengan mutex dan kanal sebelum mempelajari detail ini.

Langkah pertama dan sumber daya untuk mempelajari konkurensi dan atom

Jika Anda memasuki arena tanpa pengalaman sebelumnya, tindakan yang paling bijaksana adalah membangun fondasi konsep umum yang kuat sebelum mempelajari alat-alat canggih seperti tipe atomik Rust. Buku-buku seperti "Programming Rust" menawarkan pengenalan bertahap, tetapi wajar jika karya-karya yang berfokus pada tipe atomik dan kunci terasa padat pada awalnya.

Untuk memudahkan, sebaiknya Anda terlebih dahulu membiasakan diri dengan Utas tradisional, pengecualian bersama, dan penyampaian pesan di Rust. Bermain dengan contoh-contoh std::thread, std::sync::Mutex, std::sync::Arc dan saluran std::sync::mpsc Ini membantu Anda memahami bagaimana kompiler memandu Anda dan kesalahan apa yang dihindarinya.

Secara paralel, sangat disarankan untuk meninjau sumber daya pengantar tentang konkurensi secara umum, bahkan jika sumber daya tersebut tidak berfokus pada Rust: memahami apa itu kondisi balapan, apa arti pemblokiran, apa arti memori bersama versus penyampaian pesan, dan bagaimana kunci digunakan. Begitu konsep-konsep itu menjadi alami bagi Anda, fisika atom berhenti menjadi "sihir hitam". dan mereka menjadi sekadar alat biasa, hanya saja sangat rapuh.

Saat Anda kembali ke teks tingkat lanjut tentang atomics dan kunci di Rust, akan jauh lebih mudah untuk mengikuti alasannya jika Anda sudah memahami masalah apa yang coba dipecahkan oleh setiap konstruksi: dari penghitung thread-safe sederhana hingga struktur bebas kunci yang meminimalkan pertentangan.

Pada akhirnya, Rust menawarkan primitif tingkat tinggi dan alat tingkat sangat rendah, dan kuncinya adalah selalu memilih tingkat abstraksi teraman yang memecahkan masalah Anda, dengan menggunakan kode atom. unsafe hanya jika hal itu benar-benar menambah nilai dan Anda sepenuhnya memahami implikasinya.

Seluruh ekosistem tipe, kepemilikan, peminjaman, peti, alat, dan primitif konkurensi ini bergabung untuk menawarkan bahasa untuk menulis perangkat lunak yang cepat, kuat, dan mudah dipeliharaHal ini meminimalkan berbagai jenis kesalahan yang selama ini mengganggu pemrograman sistem. Saat Anda berlatih dengan proyek-proyek kecil, latihan seperti Rustlings, dan dokumentasi resmi, konsep-konsep ini akan berubah dari sekadar aturan ketat menjadi sekutu yang memperingatkan Anda sebelum masalah mencapai tahap produksi.