Rust-zelfstudie: geheugenveiligheid en gelijktijdigheid

Rust is een van die talen geworden die Iedere systeemontwikkelaar hoort het steeds weer.Het is net zo snel als C en C++, maar met een bijna obsessieve focus op geheugenveiligheid en goed uitgevoerde gelijktijdigheid. Dit is geen loze marketing: het ontwerp draait om de compiler die fouten detecteert tijdens het compileren – fouten die je in andere programmeertalen pas ziet als het systeem al in productie is... of wanneer het crasht.

Als u geïnteresseerd bent in begrip Hoe Rust veilig geheugen zonder garbage collection en gelijktijdigheid zonder angst voor data runs bereiktDeze tutorial is voor jou. We behandelen alles, van de basisprincipes van de taal en het ecosysteem tot belangrijke concepten zoals eigendom, lenen, samengestelde typen, tools zoals Cargo, en bekijken zelfs atomaire typen en vergrendeling vanuit een toegankelijker perspectief voor degenen die nog niet bekend zijn met gelijktijdigheid. Dit alles met een focus op beveiliging en prestaties.

Rust-zelfstudie: prestaties, geheugenveiligheid en gelijktijdigheid

Rust is een programmeertaal programmering algemeen doel en multi-paradigma, ontworpen voor zowel voor laagwaardige systeemprogrammering als voor projecten op hoog niveau, van besturingssystemenVan game-engines en browsers tot high-performance webservices: het is ontstaan ​​bij Mozilla met als doel de beveiliging van software te verbeteren, vooral in gevoelige componenten zoals een browser-engine.

Het bepalende kenmerk ervan is dat garandeert geheugenveiligheid tijdens compilatietijd zonder een garbage collector te gebruiken. In plaats daarvan maakt Rust gebruik van een eigendomssysteem en een leencontrole die de levensduur van elke waarde en de bijbehorende referenties bijhoudt. Dit voorkomt klassieke problemen zoals zwevende pointers, bufferoverlopen of geheugenlekken, zonder dat automatische referentietelling of garbage collection nodig is.

Bovendien is Rust ontworpen om het gemakkelijker te maken veilige gelijktijdigheidHet type- en eigendomsmodel voorkomt dataraces tussen threads, tenminste zolang de code veilig blijft in Rust. Dit betekent dat veel gevaarlijke situaties al tijdens de compilatie worden gedetecteerd, nog voordat er ook maar één regel is uitgevoerd.

Om al deze redenen zijn grote bedrijven zoals Dropbox, Microsoft, Amazon of Google Ze hebben Rust geïmplementeerd in cruciale onderdelen van hun infrastructuur. En het is geen toeval dat het al jaren bovenaan de Stack Overflow-polls staat als een van de "meest geliefde" talen onder ontwikkelaars: het combineert C++-achtige prestaties met een moderne toolset (Cargo, crates.io) en een zeer actieve community, de zogenaamde Rustaceans.

Basisconcepten: programmeertaal, typen en geheugen

Voordat we dieper ingaan op de specifieke aspecten van geheugenbeveiliging en gelijktijdigheid, is het de moeite waard om enkele algemene concepten te verduidelijken die overal in dit artikel voorkomen. de tijd Bij het werken met Rust, vooral als je van andere talen komt of net begint met programmeren.

Een programmeertaal is uiteindelijk een reeks regels en structuren waarmee u algoritmen kunt beschrijven en ze omzetten in uitvoerbare programma's. Rust compileert naar native machinecode met behulp van zijn compiler. rustcDe prestaties die u krijgt, zijn daarom meestal vergelijkbaar met die van C en C++.

Geheugenbeheer is het proces waarbij een programma reserveert en geeft geheugenblokken vrij tijdens het draaienFouten op dit gebied zijn vaak fataal: geheugenlekken (het niet vrijgeven van ongebruikt geheugen), datacorruptie door schrijven buiten de grenzen, of het gebruiken van geheugen nadat het is vrijgegeven. Rust pakt dit aan met een zeer krachtig typesysteem en formele regels voor eigendom, lenen en levensduur.

Rust gebruikt ook termen als slimme typen en pointersEen type beschrijft wat voor soort gegevens een variabele opslaat (gehele getallen, floats, strings, structuren, enz.) en hoe deze gemanipuleerd kan worden. Slimme pointers (bijvoorbeeld Box, Rc y Arc) zijn structuren die geheugenadressen inkapselen en extra logica toevoegen om bronnen veilig te beheren, zoals het tellen van gedeelde verwijzingen of het verplaatsen van waarden naar de heap.

Op het gebied van concurrentie worden begrippen als raceomstandigheden, mutexen en kanalen Ze zijn onmisbaar: er ontstaat een raceconditie als meerdere threads tegelijkertijd toegang hebben tot een gedeelde bron en deze wijzigen zonder dat er sprake is van goede coördinatie. Een mutex (wederzijdse uitsluiting) zorgt ervoor dat er altijd maar één thread de kritieke sectie betreedt. Dankzij kanalen kunnen berichten tussen threads worden verzonden zonder dat er rechtstreeks geheugen wordt gedeeld.

Waarom Rust leren: geheugenveiligheid en onverschrokken gelijktijdigheid

Rust heeft zijn roem verdiend omdat het biedt drie zeer waardevolle pijlers voor moderne programmeringPrestaties, beveiliging en huidige tools. Laten we eens kijken waarom deze punten zo relevant zijn.

Wat betreft de prestaties, Rust compileert direct naar native binaries zonder dat er een virtuele machine of interpreter nodig is. Het zero-cost abstractiemodel zorgt ervoor dat abstracties op hoog niveau geen overhead toevoegen tijdens runtime. Daarom is het ideaal voor systeemontwikkeling. videogames, browsercomponenten of microservices met lage latentie.

De beveiliging van het geheugen is gebaseerd op zijn eigendoms- en leensysteemEr is geen garbage collector, maar de compiler weet precies wie de eigenaar is van elke resource, wanneer deze niet langer nodig is en wanneer deze vrijgegeven kan worden. Dit voorkomt lekken, losstaande pointers en veel van de fouten die programmeren in C en C++ traditioneel zo gevaarlijk maken.

Op het gebied van concurrentie streeft Rust naar wat gewoonlijk wordt genoemd “gelijktijdigheid zonder angst”Het typesysteem zelf voorkomt dat dataroots in veilige code bestaan. Als u veranderlijke data tussen threads wilt delen, moet u geschikte primitieven gebruiken, zoals Mutex, RwLock o Arc, en de compiler zorgt ervoor dat de aliasing- en veranderlijkheidsregels worden gerespecteerd.

De ontwikkelervaring wordt verbeterd met moderne hulpmiddelen zoals CargoHet beschikt over een geïntegreerde pakketbeheerder en bouwinfrastructuur, en een uitgebreid ecosysteem van bibliotheken (crates) die alles bestrijken, van asynchrone netwerken (Tokyo) tot webframeworks (Actix, Rocket, Axum). Dit alles wordt ondersteund door een open, productieve en zeer geduldige community, met name voor beginners.

Installatie en essentiële gereedschappen: rustup, rustc en Cargo

Om uw eerste programma's in Rust te schrijven en uit te voeren, is de gebruikelijke manier om te beginnen met het installeren van de officiële toolchain met behulp van roest (zie de Volledige introductie tot Rust), een eenvoudig installatieprogramma en versiebeheerder die op alle belangrijke besturingssystemen werkt.

met roest Je kunt verschillende versies van Rust (stable, beta, nightly) installeren, updaten en ertussen wisselen zonder iets te veranderen. Ga gewoon naar de officiële Rust-toolpagina en volg de stappen voor jouw systeem. Na de installatie is de compiler beschikbaar. rustc, de projectmanager cargo en de eigen rustup in jouw terminal.

de samensteller rustc Het is wat je broncode omzet in uitvoerbare binaire bestanden of bibliotheken. Hoewel je het rechtstreeks kunt aanroepen met commando's als rustc main.rsIn de praktijk werk je vrijwel altijd via Cargo, dat de gesprekken afhandelt rustc met de juiste opties.

Het centrale hulpmiddel van de workflow is CargoMet slechts een paar opdrachten kunt u nieuwe projecten aanmaken, afhankelijkheden beheren, pakketten compileren, uitvoeren, testen en publiceren op crates.io. Enkele veelgebruikte basisopdrachten zijn: cargo new, cargo build, cargo run, cargo test y cargo check, die de code controleert zonder het uiteindelijke uitvoerbare bestand te produceren. Ideaal voor het snel detecteren van fouten.

Als je wilt knutselen zonder iets te installeren, Roest Speeltuin (de officiële online-uitvoerder) en platforms zoals Replit maken het mogelijk om kleine stukjes code te schrijven en uit te voeren vanuit de browser, ideaal om te experimenteren met geheugen- en gelijktijdigheidsvoorbeelden zonder dat u de hele omgeving hoeft in te stellen.

Je eerste programma: Hallo, Rust en basisstroom

De klassieke manier om een ​​gesprek in welke taal dan ook te beginnen is met de beroemde "Hallo, wereld". In Rust is een bestand main.rs zou op zijn minst iets zo eenvoudigs als een functie kunnen bevatten main die een string op het scherm afdrukt.

Het sleutelwoord fn geeft aan dat we een functie definiëren, en main Dit is het startpunt van het programma. Het codeblok van de functie komt tussen de accolades. Om naar de console te schrijven, gebruikt u de macro println!, die een letterlijke tekenreeks (of een sjabloon met bladwijzers) accepteert en deze naar de standaarduitvoer stuurt, eindigend met een nieuwe regel.

Als u rechtstreeks compileert met rustc main.rs, dan ontvangt u een uitvoerbaar binair bestand (bijvoorbeeld main o main.exe (afhankelijk van het systeem). Wanneer je het uitvoert, zie je het bericht in de terminal. Maar de idiomatische manier om met Rust te werken is om Cargo de leiding over het project te laten nemen.

met cargo new nombre_proyecto Er wordt automatisch een mappenstructuur aangemaakt met een src/main.rs al voorbereid met een "Hallo, wereld" en een bestand Cargo.toml die metadata en toekomstige afhankelijkheden bevat. Van daaruit, cargo run compileer en voer het binaire bestand uiten het compileert alleen opnieuw als het wijzigingen detecteert.

Deze manier van werken is niet alleen handig, maar zorgt er ook voor dat je vanaf het begin gewend raakt aan het standaard Rust-ecosysteem. Dat is erg handig als je kratten gaat toevoegen voor gelijktijdigheid, netwerken, testen of wat je ook nodig hebt.

// We declareren de hoofdfunctie: programma-invoerpunt fn main() { // We gebruiken de println!-macro om tekst naar de console te println!("Hallo, wereld!"); }

Variabelen, veranderlijkheid en basisgegevenstypen

In Rust worden variabelen gedeclareerd met het trefwoord let, en standaard zijn onveranderlijkMet andere woorden: zodra u ze een waarde toewijst, kunt u deze niet meer wijzigen, tenzij u deze expliciet als veranderlijk declareert met mut.

Standaard onveranderlijkheid helpt subtiele logische fouten te voorkomen, vooral in gelijktijdige programma's waarbij meerdere threads dezelfde waarde willen wijzigen. Als u het moet wijzigen, schrijft u iets als: let mut contador = 0;Vanaf daar kunt u nieuwe waarden toewijzen aan contador.

Roest maakt ook de zogenaamde schaduwenJe kunt een nieuwe variabele met dezelfde naam binnen dezelfde scope declareren, waardoor de vorige verborgen blijft. Dit is niet hetzelfde als muteren, omdat je een nieuwe waarde creëert (die zelfs van een ander type kan zijn). Je kunt bijvoorbeeld een string converteren naar een integer met dezelfde naam, zolang het een nieuwe declaratie is met let.

Het typesysteem van Rust is statisch, wat betekent dat Het type van elke variabele is bij de compilatie bekendType-inferentie is echter behoorlijk krachtig: als je schrijft let x = 5;De compiler gaat ervan uit dat het een i32 Tenzij u anders aangeeft. U kunt notities toevoegen zoals let x: i64 = 5; als je expliciet wilt zijn.

Tot de beschikbare scalaire typen behoren de signed en unsigned integers (i8, u8, i32, enz.), de zwevende (f32, f64), de Booleaanse waarden (bool) en Unicode-tekens (char). Deze eenvoudige typen zijn meestal goedkoop te kopiëren en veel implementeren de eigenschap CopyDit betekent dat wanneer u ze toewijst of doorgeeft aan een functie, ze worden gekopieerd in plaats van verplaatst.

Strings in Rust: &str en String

Tekstverwerking in Rust kan in het begin wat verwarrend zijn, omdat er duidelijk onderscheid wordt gemaakt tussen keten "slices" en gepatenteerde ketensDe twee belangrijkste stukken zijn &str y String.

Un &str is een stukje onveranderlijke ketenEen weergave van een ergens opgeslagen UTF-8-bytereeks. Typische voorbeelden zijn letterlijke waarden zoals "Hola"die van het type zijn &'static str (Ze bestaan ​​gedurende de gehele levensduur van het programma en zijn in het binaire bestand ingesloten.) Slices zijn niet de eigenaar van de gegevens; ze verwijzen er alleen naar.

Stringis daarentegen een eigen string, veranderlijk en gehost in de heapU kunt de grootte ervan aanpassen, het samenvoegen en het doorgeven tussen functies door de eigenschappen ervan te verplaatsen, enzovoort. Het wordt vaak gebruikt als u dynamische tekst wilt maken of tekst langdurig wilt opslaan binnen structuren.

In veel scenario's zul je tussen de ene en de andere transformeren: je zult bijvoorbeeld een String::from("hola") van een plakjeof je leent een &str een String door verwijzingen door te geven naar functies die alleen hoeven te lezen.

Deze scheiding tussen eigen en geleende gegevens is essentieel voor geheugenbeheer en geldt ook voor de rest van de taal: verzamelingen, structuren en enums volgen hetzelfde idee van wie eigenaar is en wie er alleen naar kijkt.

Functies, besturingsstroom en opmerkingen

Functies in Rust worden gedefinieerd met fn en zorgen ervoor dat het programma kan worden georganiseerd in herbruikbare logische eenheden. Elke functie specificeert het type van de parameters en het retourtype een pijl volgen ->Als er geen betekenisvolle resultaten worden geretourneerd, wordt het unitaire type aangenomen. ().

Een belangrijk detail is dat de laatste expressie in een functie (of een blok) zonder puntkomma als impliciete retourwaarde wordt beschouwd. U kunt return voor vervroegde terugkeerMaar in idiomatische code laat je de laatste expressie vaak gewoon weg. ;.

De besturingsstroom wordt afgehandeld met de klassiekers if/elselussen loop, while y forIn Rust, if Het is een expressie die een waarde retourneertzodat je het direct in een letop voorwaarde dat de takken hetzelfde type retourneren. Lussen for Ze itereren doorgaans over bereiken of verzamelingsiteratoren en zijn de aanbevolen optie in plaats van handmatige indexen.

Om de code te documenteren en het leven makkelijker te maken voor iedereen die na jou komt (inclusief jezelf over een maand), kun je het volgende gebruiken: regel opmerkingen met // of blokkeren met /* ... */Bovendien biedt Rust documentatiecommentaar met /// die gegenereerde documenten worden, hoewel dat meer geschikt is voor grotere projecten.

Eigendom, uitlenen en levensduur: de basis van geheugenbeveiliging

Hier komen we tot de kern van Rusts geheugenmodel: het systeem van eigendom, lenen en levensduurDeze regels zorgen ervoor dat verwijzingen altijd geldig zijn en dat het geheugen veilig wordt vrijgegeven, zonder dat er rommel wordt opgeslagen.

De basisregels voor eigendom zijn eenvoudig te benoemen, al kan het in het begin lastig zijn om ze te internaliseren: Elke waarde heeft één eigenaar.Er kan maar één eigenaar tegelijk zijn; en wanneer de eigenaar zijn bereik verlaat, wordt de waarde vernietigd en het geheugen vrijgegeven. Dit geldt bijvoorbeeld voor een String: zodra het blok waarin het is gedeclareerd is voltooid, wordt het automatisch aangeroepen drop waardoor het heapgeheugen vrijkomt.

Wanneer u een juiste waarde toewijst aan een andere variabele of deze als waarde doorgeeft aan een functie, wordt de eigenschap verplaatst. Dit betekent dat de oorspronkelijke variabele is niet meer geldig na de verplaatsingDeze bewegingssemantiek voorkomt dubbele releases, omdat er nooit twee eigenaren zijn die dezelfde bron proberen vrij te geven.

Om meerdere onderdelen van het programma toegang te geven tot dezelfde waarde zonder van eigenaar te wisselen, introduceert Rust referenties en lenen. Wanneer u leent, maakt u een referentie aan. &T (onveranderlijk) of &mut T (veranderlijk) aan de waarde zonder eigendom over te dragen. De lening is beperkt door de regels van de leningverificateur., die controleert of referenties niet langer meegaan dan de data waarnaar ze verwijzen en of veranderlijke en gedeelde toegangen niet gevaarlijk worden gemengd.

De regels van de lening kunnen als volgt worden samengevat: op elk willekeurig moment kunt u: meerdere onveranderlijke verwijzingen naar een waarde, of een enkele veranderlijke referentieMaar niet beide tegelijk. Dit elimineert racecondities in gedeeld geheugen: er zijn óf veel lezers, óf er is een geïsoleerde schrijver; nooit gelijktijdige lezers en schrijvers van dezelfde data op hetzelfde moment.

Samengestelde typen: structs, enums en slimme pointers

Rust biedt verschillende manieren om gerelateerde gegevens in rijkere structuren te groeperen, te beginnen met de structurenMet een struct kunt u een aangepast type definiëren met benoemde velden, bijvoorbeeld een gebruiker met e-mailadres, naam, activiteitsstatus en aanmeldteller.

Om een ​​instantie van een struct te maken, vult u alle velden in en kunt u de variabele die deze bevat markeren als veranderlijk om de waarden later te wijzigen. Er is ook de struct update-syntaxis, waarmee u een nieuwe instantie kunt bouwen door velden uit een bestaande instantie te hergebruiken. ..otro_struct.

De opsommingen Ze vormen een andere essentiële pijler: ze stellen je in staat een type te definiëren dat een van de verschillende mogelijke varianten kan zijn, elk met of zonder bijbehorende gegevens. Een klassiek voorbeeld is een enum voor IP-adressen, met één variant. V4 die vier octetten en nog een opslaat V6 die een tekenreeks met IPv6-notatie opslaat.

De standaardbibliotheek van Rust bevat twee zeer belangrijke enums: Option<T> y Result<T, E>De eerste representeert de aanwezigheid of afwezigheid van een waarde (iets of niets) en wordt gebruikt om null-pointers te vermijden; de tweede modelleert bewerkingen die een correct resultaat of een fout retourneren, waarbij vereist is dat foutverwerking expliciet en veilig is.

Om dynamisch geheugen te beheren en gegevens te delen, heeft Rust slimme aanwijzers als Box<T>, die een waarde naar de heap verplaatst en het unieke eigenaarschap behoudt; Rc<T>een gedeelde referentietelling voor single-threaded omgevingen; en Arc<T>, vergelijkbaar met Rc maar veilig voor meerdere threads. Correct gebruik ervan is cruciaal bij het combineren van dynamisch geheugen met gelijktijdigheid.

Vracht en het kratten-ecosysteem

Cargo is de lijm die het Rust-ecosysteem bij elkaar houdt: beheert de compilatie, afhankelijkheden en projectlevenscyclusElk project heeft een bestand Cargo.toml dat als manifest fungeert en de naam, versie, taaleditie en externe afhankelijkheden aangeeft.

De sectie Met dit bestand kunt u crates van derden met hun versies weergeven. Wanneer u cargo build o cargo runCargo downloadt deze crates automatisch van crates.io, compileert ze en koppelt ze aan je project. Zo eenvoudig is het om bijvoorbeeld random number generators, webframeworks of cryptografische bibliotheken toe te voegen.

Tot de meest voorkomende commando's behoren: cargo new om binaire projecten te starten o cargo new --lib voor bibliotheken; cargo build compileren in debug-modus; cargo build --release om een ​​geoptimaliseerde, productiegerichte versie te verkrijgen; en cargo test om de batterij aan tests uit te voeren.

cargo check Het verdient een speciale vermelding: het compileert de code naar een tussenliggend punt zonder een binair bestand te genereren, waardoor het zeer snel zijn in het detecteren van compilatiefoutenHet is perfect om snel te itereren, terwijl de leencontrole problemen met eigenschappen, referenties en levensduur aan het licht brengt.

Dankzij dit ecosysteem is het gebruikelijk om je projecten te structureren als kleine, goed gedefinieerde crates, waarbij code tussen de crates wordt gedeeld en oplossingen van de community worden hergebruikt. Voor geavanceerde gelijktijdigheid heb je bijvoorbeeld crates zoals Tokio voor asynchrone programmering of crossbeam voor krachtige gelijktijdige datastructuren.

Gelijktijdigheid in Rust: threads, mutexen, kanalen en atomen

Gelijktijdigheid is een van de redenen waarom Rust zoveel belangstelling wekt: het biedt u de mogelijkheid om te profiteren van multi-core processors. zonder te vervallen in de typische fouten van threads en gedeeld geheugenAls dit de eerste keer is dat u zich met deze onderwerpen bezighoudt, is het nuttig om onderscheid te maken tussen verschillende concepten.

Gelijktijdigheid houdt in dat meerdere taken worden uitgevoerd die elkaar overlappen in de tijd, op één of meerdere cores. In Rust kunt u systeemthreads aanmaken om parallel werk uit te voeren, en de taal helpt u ervoor te zorgen dat de gegevensuitwisseling tussen hen veilig is. Een klassieke fout is de raceconditie, waarbij twee threads gelijktijdig toegang hebben tot gegevens en deze wijzigen, en het resultaat afhankelijk is van de uitvoeringsvolgorde – iets wat zeer moeilijk te debuggen is.

Om de toegang tot gedeelde gegevens te coördineren, vertrouwt Rust op primitieven zoals mutexdie wederzijdse uitsluiting garanderen: slechts één thread kan tegelijk de kritieke sectie betreden. In combinatie met Arc<T> Om het eigendom tussen threads te delen, is het mogelijk om gedeelde datastructuren te bouwen die voldoen aan de regels voor eigendom en lenen.

Een andere veelvoorkomende vorm van inter-threaded communicatie, die in Rust sterk wordt aangemoedigd, is het doorgeven van berichten met behulp van canalesEen kanaal heeft een verzendende en een ontvangende kant. Threads sturen berichten (waarden) via het kanaal, waardoor er minder veranderlijk gedeeld geheugen nodig is en het redeneren over de status van het systeem eenvoudiger wordt.

Wanneer u zich verdiept in gelijktijdigheid op laag niveau, verschijnen de volgende resultaten: atomaire typenAtomaire variabelen worden benaderd via bewerkingen die vanuit een threadperspectief ondeelbaar zijn. Dit maakt de implementatie van gedeelde tellers, statusvlaggen, lock-free wachtrijen en meer mogelijk. Het beheersen van atomaire variabelen vereist inzicht in geheugenmodellen en toegangsopdrachten. Veel ontwikkelaars beginnen daarom liever met mutexen en kanalen voordat ze zich in deze details verdiepen.

Eerste stappen en hulpmiddelen voor het leren van gelijktijdigheid en atomaire

Als je de arena betreedt zonder enige ervaring, is het verstandigste om te doen: een solide basis van algemene concepten opbouwen voordat je aan de slag gaat met geavanceerde tools zoals de atomaire typen van Rust. Boeken zoals "Programming Rust" bieden een geleidelijke introductie, maar het is normaal dat werken die zich richten op atomaire typen en vergrendelingen in het begin complex lijken.

Voor meer gemak is het raadzaam om eerst kennis te maken met Traditionele discussies, wederzijdse uitsluiting en het doorgeven van berichten in Rust. Speel met voorbeelden van std::thread, std::sync::Mutex, std::sync::Arc en kanalen van std::sync::mpsc Het helpt u te begrijpen hoe de compiler u begeleidt en welke fouten deze vermijdt.

Daarnaast is het ten zeerste aan te raden om inleidende bronnen over gelijktijdigheid in het algemeen te bekijken, zelfs als ze niet specifiek op Rust gericht zijn: begrijp wat race-omstandigheden zijn, wat blokkeren inhoudt, wat gedeeld geheugen inhoudt versus berichtdoorgifte en hoe vergrendelingen worden gebruikt. Zodra deze concepten voor u vanzelfsprekend zijn geworden, is atoomfysica geen 'zwarte magie' meer. en ze worden gewoon een gereedschap, maar dan wel een heel delicaat.

Wanneer u terugkeert naar meer geavanceerde teksten over atomics en locks in Rust, wordt het veel gemakkelijker om de redenering te volgen als u al begrijpt welk probleem elke constructie probeert op te lossen: van een eenvoudige thread-safe teller tot lock-vrije structuren die de concurrentie minimaliseren.

Uiteindelijk biedt Rust zowel primitieven op hoog niveau als hulpmiddelen op zeer laag niveau. Het belangrijkste is dat u altijd het veiligste abstractieniveau kiest dat uw probleem oplost, en daarbij gebruikmaakt van atomaire code. unsafe alleen als het echt waarde toevoegt en u de implicaties ervan volledig begrijpt.

Dit hele ecosysteem van typen, eigendom, lenen, kratten, gereedschappen en gelijktijdigheidsprimitieven combineert om een ​​taal te bieden waarin geschreven kan worden snelle, robuuste en onderhoudbare softwareDit minimaliseert veel soorten fouten die systeemprogrammering van oudsher plagen. Naarmate je oefent met kleine projecten, oefeningen zoals Rustlings en officiële documentatie, zullen deze concepten veranderen van strikte regels naar een bondgenoot die je waarschuwt voordat het probleem de productie bereikt.