En guide til rusts fryktløse samtidighet

Samtidighet er muligheten til et program til å utføre flere oppgaver samtidig på samme CPU-kjerne. Samtidige oppgaver kjører og fullføres i overlappende tid uten spesifisert rekkefølge, i motsetning til parallellitet, hvor ulike oppgaver eller deloppgaver av samme oppgave kjøres samtidig på maskinvare med flere prosessorer.

Rust skiller seg ut for sine ytelsesfunksjoner og støtte for samtidighet på en sikker og effektiv måte. Rusts tilnærming til samtidighet er basert på konseptet "fearless concurrency" der språket har som mål å gjøre det enkelt å skrive trygt samtidig kode gjennom eierskaps- og lånesystemet som håndhever strenge regler ved kompilering for å forhindre dataspor og sikrer minne sikkerhet.

Forstå samtidighet i rust

Rust gir flere samtidige primitiver for å skrive samtidige programmer, inkludert tråder, meldingsoverføring, mutexes, atomtyper og asynkron/avvent for asynkron programmering.

Her er en oversikt over Rusts samtidighetsprimitiver:

1. Tråder: Rust gir en std:: tråd modul i standardbiblioteket for å lage og administrere tråder. Du kan skape nye tråder med tråd:: spawn funksjon. De tråd:: spawn tar en avslutning som inneholder koden for utførelse. Du kan også kjøre tråder som kan kjøres parallelt, og Rust gir synkroniseringsprimitiver for å koordinere utførelsen av dem. Lånekontrollen sikrer at referanser ikke fører til uventet oppførsel.
2. Melding passerer: Rusts samtidighetsmodell støtter meldingsoverføring mellom tråder. Du vil bruke kanalene implementert gjennom std:: sync:: mpsc modul for meldingsoverføring. En kanal består av en sender (Avsender) og en mottaker (Mottaker). Tråder kan sende meldinger gjennom senderen og motta dem gjennom mottakeren. Dette gir en sikker og synkronisert måte å kommunisere mellom tråder på.
3. Mutexes og atomtyper: Rust gir synkroniseringsprimitiver, inkludert mutexes (std:: sync:: Mutex) og atomtyper (std:: sync:: atomic), for å sikre eksklusiv tilgang til datadeling. Mutexes lar flere tråder få tilgang til data samtidig mens de forhindrer dataløp. Atomtyper gir atomoperasjoner på delte data, for eksempel å øke en teller, uten å kreve eksplisitt låsing.
4. Async/Await og Futures: Rust sin asynkron/avvente syntaks gir funksjonalitet for å skrive asynkron kode som du kan kjøre samtidig. Asynkrone programmer håndterer effektivt I/O-bundne oppgaver som gjør det mulig for programmer å utføre andre oppgaver mens de venter på andre I/O-operasjoner. Rust sin asynkron/avvente syntaks er basert på futures, og du kan drive dem med asynkron-std eller tokio kjøretidsbiblioteker.

Rusttråder er lette, og fraværet av driftskostnader gjør dem godt egnet for høyytelsesapplikasjoner. Rusts samtidighetsprimitiver integreres sømløst med flere biblioteker og rammeverk for ulike samtidighetsbehov.

Slik bruker du spawn-tråder i rust

Du vil bruke std:: tråd modul for å skape tråder. De std:: tråd:: spawn funksjonen lar deg lage en ny tråd som kjøres samtidig med hovedtråden eller andre eksisterende tråder i programmet.

Her er hvordan du kan lage en tråd med std:: tråd:: spawn funksjon:

bruk std:: tråd;
fnhoved-() {
// Lag en ny tråd
la thread_handle = thread:: spawn(|| {
// Koden utført i den nye tråden går her
println!("Hei fra den nye tråden!");
 });
// Vent til den opprettede tråden er ferdig
 thread_handle.join().unwrap();
// Kode utført i hovedtråden fortsetter her
println!("Hei fra hovedtråden!");
}

De hoved- funksjonen oppretter en ny tråd med tråd:: spawn funksjon ved å sende inn en lukking som inneholder koden for utførelsen i tråden (i dette tilfellet er stengingen en anonym funksjon). Lukkingen skriver ut en melding som indikerer at den nye tråden kjører.

De bli med metode på thread_handle lar hovedtråden vente på at den opprettede tråden fullføres. Ved å ringe bli med, sikrer funksjonen at hovedtråden venter på at den opprettede tråden fullføres før du fortsetter.

Du kan spawne flere tråder og bruke en løkke eller en hvilken som helst annen Rustkontrollstruktur for å lage flere nedleggelser og opprette tråder for hver.

bruk std:: tråd;
fnhoved-() {
la antall_tråder = 5;
lamut thread_handles = vec![];
til Jeg i0..antall_threads {
la thread_handle = thread:: spawn(bevege seg || {
println!("Hei fra tråden {}", Jeg);
 });
 thread_handles.push (thread_handle);
 }
til håndtak i trådhåndtak {
 handle.join().unwrap();
 }
println!("Alle tråder ferdig!");
}

For-løkken skaper fem tråder, hver tildelt en unik identifikator Jeg med loop-variabelen. Nedleggelsene fanger opp verdien av Jeg med bevege seg nøkkelord å unngå eierskapsspørsmål, og trådhåndtak vektor lagrer trådene for senere i bli med Løkke.

Etter gyting av alle trådene, den hoved- funksjonen itererer over trådhåndtak vektor, samtaler bli med på hvert håndtak, og venter på at alle trådene skal utføres.

Sende meldinger gjennom kanaler

Du kan sende meldinger gjennom tråder med kanaler. Rust gir funksjonalitet for meldingsoverføring i std:: sync:: mpsc modul. Her, mpsc står for "multiple producer, single consumer" og det tillater kommunikasjon mellom flere tråder ved å sende og motta meldinger gjennom kanaler.

Slik implementerer du budskap som går gjennom kanaler for kommunikasjon mellom tråder i programmene dine:

bruk std:: sync:: mpsc;
bruk std:: tråd;
fnhoved-() {
// Opprett en kanal
la (sender, mottaker) = mpsc:: channel();
// Lag en tråd
 tråd:: spawn(bevege seg || {
// Send en melding via kanalen
 sender.send("Hei fra tråden!").unwrap();
 });
// Motta meldingen i hovedtråden
la mottatt_melding = mottaker.mottak().unwrap();
println!("Mottatt melding: {}", mottatt_melding);
}

De hoved- funksjonen oppretter en kanal med mpsc:: kanal() som returnerer en avsender og a mottaker. De avsender sender meldinger til mottaker som mottar meldingene. De hoved- funksjonen fortsetter å skape tråder og flytte eierskapet til Avsender til trådlukkingen. Inne i trådlukkingen er den sender.send() funksjonen sender en melding gjennom kanalen.

De receiver.recv() funksjon mottar meldingen ved å stoppe kjøringen til tråden har mottatt meldingen. De hoved- funksjonen skriver ut meldingen til konsollen etter en vellykket meldingsmottak.

Merk at det å sende en melding gjennom kanalen tærer på avsenderen. Hvis du trenger å sende meldinger fra flere tråder, kan du klone avsenderen med sender.clone() funksjon.

I tillegg har mpsc modulen gir andre metoder som try_recv(), som ikke-blokkerende prøver å motta en melding, og iter(), som lager en iterator over de mottatte meldingene.

Meldingsoverføring via kanaler gir en sikker og praktisk måte å kommunisere mellom tråder på, samtidig som man unngår dataløp og sikrer riktig synkronisering.

Rusts eierskap og lånemodell garanterer minnesikkerhet

Rust kombinerer eierskap, lån og lånekontroll for å gi et robust, trygt, samtidig programmeringsrammeverk.

Lånekontrollen fungerer som et sikkerhetsnett, og oppdager potensielle problemer ved kompilering i stedet for å stole på kjøretidssjekker eller søppelinnsamling.