Een gids voor de onbevreesde gelijktijdigheid van Rust

Gelijktijdigheid is het vermogen van een programma om meerdere taken tegelijkertijd uit te voeren op dezelfde CPU-kern. Gelijktijdige taken worden uitgevoerd en voltooid in overlappende tijd zonder gespecificeerde volgorde, in tegenstelling tot parallellisme, waarbij verschillende taken of subtaken van dezelfde taak tegelijkertijd worden uitgevoerd op hardware met meerdere verwerkers.

Rust onderscheidt zich door zijn prestatiekenmerken en ondersteuning voor gelijktijdigheid op een veilige, efficiënte manier. Rust's benadering van concurrency is gebaseerd op het concept van "onbevreesde concurrency", waarbij de taal tot doel heeft het gemakkelijk te maken om veilig te schrijven gelijktijdige code via het eigendoms- en leensysteem dat tijdens het compileren strikte regels afdwingt om gegevenssporen te voorkomen en geheugen te garanderen veiligheid.

Gelijktijdigheid in Rust begrijpen

Rust biedt verschillende concurrency-primitieven voor het schrijven van gelijktijdige programma's, waaronder threads, het doorgeven van berichten, mutexen, atomaire typen en async/wait voor asynchrone programmering.

Hier is een overzicht van de concurrency-primitieven van Rust:

1. Draden: Roest zorgt voor een std:: draad module in de standaardbibliotheek voor het maken en beheren van threads. Je kunt nieuwe threads spawnen met de draad:: spawn functie. De draad:: spawn neemt een afsluiting met de code voor uitvoering. U kunt ook threads uitvoeren die parallel kunnen lopen, en Rust biedt synchronisatieprimitieven om hun uitvoering te coördineren. De leenchecker zorgt ervoor dat verwijzingen niet leiden tot onverwacht gedrag.
2. Bericht overslaan: Het concurrency-model van Rust ondersteunt het doorgeven van berichten tussen threads. Je gebruikt de kanalen die zijn geïmplementeerd via de std:: sync:: mpsc module voor het doorgeven van berichten. Een kanaal bestaat uit een zender (Afzender) en een ontvanger (Ontvanger). Threads kunnen berichten verzenden via de zender en ontvangen via de ontvanger. Dit zorgt voor een veilige en gesynchroniseerde manier van communiceren tussen threads.
3. Mutexen en atomaire typen: Rust biedt synchronisatieprimitieven, inclusief mutexen (std:: sync:: Mutex) en atomaire typen (std:: sync:: atomair), om exclusieve toegang tot het delen van gegevens te garanderen. Met mutexes kunnen meerdere threads gelijktijdig toegang krijgen tot gegevens terwijl gegevensraces worden voorkomen. Atomic-typen bieden atomaire bewerkingen op gedeelde gegevens, zoals het verhogen van een teller, zonder dat expliciete vergrendeling vereist is.
4. Async/Await en Futures: Roest asynchroon/wachten syntaxis biedt functionaliteit voor het schrijven van asynchrone code die u gelijktijdig kunt uitvoeren. Asynchrone programma's gaan efficiënt om met I/O-gebonden taken, waardoor programma's andere taken kunnen uitvoeren terwijl ze wachten op andere I/O-bewerkingen. Roest asynchroon/wachten syntaxis is gebaseerd op futures en u kunt ze van stroom voorzien met de asynchrone standaard of Tokio runtime bibliotheken.

Roestdraden zijn licht van gewicht en de afwezigheid van runtime-overhead maakt ze zeer geschikt voor hoogwaardige toepassingen. De concurrency-primitieven van Rust integreren naadloos met meerdere bibliotheken en frameworks voor verschillende concurrency-behoeften.

Spawn-threads gebruiken in roest

Je gebruikt de std:: draad module om threads te spawnen. De std:: draad:: spawn Met de functie kunt u een nieuwe thread maken die gelijktijdig met de hoofdthread of andere bestaande threads in uw programma wordt uitgevoerd.

Hier leest u hoe u een thread kunt spawnen met de std:: draad:: spawn functie:

gebruik standaard:: draad;
fnvoornaamst() {
// Spawn een nieuwe thread
laten thread_handle = draad:: spawn(|| {
// Code uitgevoerd in de nieuwe thread komt hier
println!("Hallo van de nieuwe draad!");
 });
// Wacht tot de voortgebrachte thread is voltooid
 thread_handle.join().uitpakken();
// Code uitgevoerd in de hoofdthread gaat hier verder
println!("Hallo uit de hoofdthread!");
}

De voornaamst functie maakt een nieuwe thread aan met de draad:: spawn functie door een sluiting door te geven die de code voor de uitvoering in de thread bevat (in dit geval is de sluiting een anonieme functie). De sluiting drukt een bericht af dat aangeeft dat de nieuwe thread actief is.

De meedoen methode op de thread_handle staat de hoofdthread toe om te wachten tot de voortgebrachte thread de uitvoering voltooit. Door te bellen meedoen, zorgt de functie ervoor dat de hoofdthread wacht tot de voortgebrachte thread is voltooid voordat verder wordt gegaan.

Je kunt meerdere threads spawnen en een lus of een andere gebruiken Roest controle structuur om voor elk meerdere sluitingen en spawn-threads te maken.

gebruik standaard:: draad;
fnvoornaamst() {
laten aantal_threads = 5;
latenmuts thread_handles = vec![];
voor i in0..aantal_threads {
laten thread_handle = draad:: spawn(beweging || {
println!("Hallo van gesprek {}", i);
 });
 thread_handles.push (thread_handle);
 }
voor hendel in thread_handles {
 handvat.join().uitpakken();
 }
println!("Alle draden zijn af!");
}

De for-lus brengt vijf threads voort, elk toegewezen aan een unieke identificatie i met de lusvariabele. De sluitingen vangen de waarde van i met de beweging trefwoord te vermijden eigendomskwesties, en de thread_handles vector slaat de threads op voor later in de meedoen lus.

Na het spawnen van alle threads, de voornaamst functie itereert over de thread_handles vector, oproepen meedoen op elke handle en wacht tot alle threads zijn uitgevoerd.

Berichten doorgeven via kanalen

U kunt berichten doorgeven via threads met kanalen. Rust biedt functionaliteit voor het doorgeven van berichten in de std:: sync:: mpsc moduul. Hier, mpsc staat voor "multiple producer, single consumer" en maakt communicatie tussen meerdere threads mogelijk door berichten via kanalen te verzenden en te ontvangen.

Zo implementeert u het doorgeven van berichten via communicatiekanalen tussen threads in uw programma's:

gebruik std:: synchronisatie:: mpsc;
gebruik standaard:: draad;
fnvoornaamst() {
// Maak een kanaal aan
laten (zender, ontvanger) = mpsc:: kanaal();
// Spawn een draad
 draad:: spawn(beweging || {
// Stuur een bericht via het kanaal
 afzender.verzenden("Hallo van de draad!").uitpakken();
 });
// Ontvang het bericht in de hoofdthread
laten ontvangen bericht = ontvanger.recv().uitpakken();
println!("Ontvangen bericht: {}", ontvangen_bericht);
}

De voornaamst functie creëert een kanaal met mpsc:: kanaal() dat geeft een terug afzender en een ontvanger. De afzender stuurt berichten naar de ontvanger die de berichten ontvangt. De voornaamst functie gaat verder met het spawnen van threads en het verplaatsen van het eigendom van de Afzender naar de draadafsluiting. Binnen de draadsluiting, de afzender.verzenden() functie stuurt een bericht via het kanaal.

De ontvanger.recv() functie ontvangt het bericht door de uitvoering te stoppen totdat de thread het bericht heeft ontvangen. De voornaamst functie drukt het bericht af naar de console na een succesvolle berichtontvangst.

Merk op dat het verzenden van een bericht via het kanaal de afzender verbruikt. Als u berichten moet verzenden vanuit meerdere threads, kunt u de afzender klonen met de afzender.kloon() functie.

Bovendien, de mpsc module biedt andere methoden zoals probeer_recv(), die niet-blokkerend probeert een bericht te ontvangen, en iter(), waarmee een iterator over de ontvangen berichten wordt gemaakt.

Het doorgeven van berichten via kanalen biedt een veilige en handige manier om tussen threads te communiceren, terwijl gegevensraces worden vermeden en een goede synchronisatie wordt gegarandeerd.

Het eigendoms- en leenmodel van Rust garandeert geheugenveiligheid

Rust combineert eigendom, lenen en de leencontrole om een ​​robuust, veilig, gelijktijdig programmeerframework te bieden.

De leencontrole fungeert als een vangnet en detecteert potentiële problemen tijdens het compileren in plaats van te vertrouwen op runtime-controles of afvalinzameling.