En guide til rusts frygtløse samtidighed

Samtidighed er et programs evne til at udføre flere opgaver samtidigt på den samme CPU-kerne. Samtidige opgaver kører og afsluttes i overlappende tid uden specificeret rækkefølge, i modsætning til parallelisme, hvor forskellige opgaver eller delopgaver af samme opgave kører på samme tid på hardware med flere processorer.

Rust skiller sig ud for sine præstationsegenskaber og understøttelse af samtidighed på en sikker og effektiv måde. Rusts tilgang til samtidighed er baseret på konceptet "fearless concurrency", hvor sproget sigter mod at gøre det nemt at skrive sikkert samtidig kode gennem dets ejerskabs- og lånesystem, der håndhæver strenge regler på kompileringstidspunktet for at forhindre dataspor og sikrer hukommelse sikkerhed.

Forståelse af samtidighed i rust

Rust giver flere samtidige primitiver til at skrive samtidige programmer, herunder tråde, meddelelsesoverførsel, mutexes, atomtyper og asynkron/afvent til asynkron programmering.

Her er en oversigt over Rusts samtidighedsprimitiver:

1. Tråde: Rust giver en std:: tråd modul i dets standardbibliotek til at oprette og administrere tråde. Du kan skabe nye tråde med tråd:: spawn fungere. Det tråd:: spawn tager en lukning indeholdende koden til udførelse. Du kan også køre tråde, der kan køre parallelt, og Rust giver synkroniseringsprimitiver til at koordinere deres udførelse. Lånekontrollen sikrer, at referencer ikke fører til uventet adfærd.
2. Besked passerer: Rusts samtidighedsmodel understøtter meddelelsesoverførsel mellem tråde. Du vil bruge kanalerne implementeret gennem std:: sync:: mpsc modul til meddelelsesoverførsel. En kanal består af en sender (Afsender) og en modtager (Modtager). Tråde kan sende beskeder gennem senderen og modtage dem gennem modtageren. Dette giver en sikker og synkroniseret måde at kommunikere mellem tråde på.
3. Mutexes og atomtyper: Rust giver synkroniseringsprimitiver, herunder mutexes (std:: sync:: Mutex) og atomtyper (std:: sync:: atom), for at sikre eksklusiv adgang til datadeling. Mutexes tillader flere tråde at få adgang til data samtidigt, mens de forhindrer dataløb. Atomtyper giver atomariske operationer på delte data, såsom stigning af en tæller, uden at kræve eksplicit låsning.
4. Async/Await og Futures: Rustens asynkron/vente syntaks giver funktionalitet til at skrive asynkron kode, som du kan udføre samtidigt. Asynkrone programmer håndterer effektivt I/O-bundne opgaver, hvilket gør det muligt for programmer at udføre andre opgaver, mens de venter på andre I/O-operationer. Rusts asynkron/vente syntaks er baseret på futures, og du kan drive dem med asynkron-std eller tokio runtime biblioteker.

Rusttråde er lette, og fraværet af driftstid gør dem velegnede til højtydende applikationer. Rusts samtidighedsprimitiver integreres problemfrit med flere biblioteker og rammer til forskellige samtidighedsbehov.

Sådan bruger du spawn-tråde i rust

Du vil bruge std:: tråd modul til at skabe tråde. Det std:: tråd:: spawn funktionen giver dig mulighed for at oprette en ny tråd, der kører samtidig med hovedtråden eller andre eksisterende tråde i dit program.

Her er hvordan du kan skabe en tråd med std:: tråd:: spawn fungere:

brug std:: tråd;
fnvigtigste() {
// Lav en ny tråd
lade thread_handle = thread:: spawn(|| {
// Koden udført i den nye tråd går her
println!("Hej fra den nye tråd!");
 });
// Vent til den affødte tråd er færdig
 thread_handle.join().unwrap();
// Kode udført i hovedtråden fortsætter her
println!("Hej fra hovedtråden!");
}

Det vigtigste funktion opretter en ny tråd med tråd:: spawn funktion ved at indsætte en lukning, der indeholder koden til udførelsen i tråden (i dette tilfælde er lukningen en anonym funktion). Lukningen udskriver en meddelelse, der angiver, at den nye tråd kører.

Det tilslutte metode på thread_handle tillader hovedtråden at vente på, at den affødte tråd fuldfører eksekveringen. Ved at ringe tilslutte, sikrer funktionen, at hovedtråden venter på, at den affødte tråd er færdig, før du fortsætter.

Du kan skabe flere tråde og bruge en loop eller en hvilken som helst anden Rustkontrolstruktur at oprette flere lukninger og skabe tråde for hver.

brug std:: tråd;
fnvigtigste() {
lade antal_tråde = 5;
lademut thread_handles = vec![];
til jeg i0..antal_tråde {
lade thread_handle = tråd:: spawn(bevæge sig || {
println!("Hej fra tråden {}"i);
 });
 thread_handles.push (tråd_håndtag);
 }
til håndtere i trådhåndtag {
 handle.join().unwrap();
 }
println!("Alle tråde afsluttet!");
}

For-løkken afføder fem tråde, der hver er tildelt en unik identifikator jeg med loop-variablen. Lukningerne fanger værdien af jeg med bevæge sig søgeord at undgå ejerskabsspørgsmål, og trådhåndtag vektor gemmer trådene til senere i tilslutte sløjfe.

Efter at have skabt alle trådene, vigtigste funktion itererer over trådhåndtag vektor, opkald tilslutte på hvert håndtag og venter på, at alle tråde udføres.

Sende beskeder gennem kanaler

Du kan sende beskeder gennem tråde med kanaler. Rust giver funktionalitet til videregivelse af beskeder i std:: sync:: mpsc modul. Her, mpsc står for "multiple producer, single consumer" og det tillader kommunikation mellem flere tråde ved at sende og modtage beskeder gennem kanaler.

Sådan implementerer du budskaber, der passerer gennem kanaler for intertrådskommunikation i dine programmer:

brug std:: sync:: mpsc;
brug std:: tråd;
fnvigtigste() {
// Opret en kanal
lade (afsender, modtager) = mpsc:: kanal();
// Lav en tråd
 tråd:: spawn(bevæge sig || {
// Send en besked via kanalen
 sender.send("Hej fra tråden!").unwrap();
 });
// Modtag beskeden i hovedtråden
lade modtaget_meddelelse = receiver.recv().unwrap();
println!("Modtaget besked: {}", modtaget_meddelelse);
}

Det vigtigste funktion opretter en kanal med mpsc:: kanal() der returnerer en afsender og en modtager. Det afsender sender beskeder til modtager der modtager beskederne. Det vigtigste funktion fortsætter med at skabe tråde og flytte ejerskabet af Afsender til trådlukningen. Inde i trådlukningen er den sender.send() funktionen sender en besked gennem kanalen.

Det receiver.recv() funktion modtager beskeden ved at standse udførelsen, indtil tråden har modtaget beskeden. Det vigtigste funktion udskriver meddelelsen til konsollen efter en vellykket meddelelsesmodtagelse.

Bemærk, at afsendelse af en besked gennem kanalen optager afsenderen. Hvis du har brug for at sende beskeder fra flere tråde, kan du klone afsenderen med sender.clone() fungere.

Derudover mpsc modul giver andre metoder som try_recv(), som ikke-blokerende forsøger at modtage en besked, og iter(), som opretter en iterator over de modtagne beskeder.

Beskedoverførsel via kanaler giver en sikker og bekvem måde at kommunikere mellem tråde på, samtidig med at man undgår dataløb og sikrer korrekt synkronisering.

Rusts ejerskabs- og lånemodel garanterer hukommelsessikkerhed

Rust kombinerer ejerskab, lån og lånekontrol for at give en robust, sikker, samtidig programmeringsramme.

Lånekontrollen fungerer som et sikkerhedsnet, der opdager potentielle problemer på kompileringstidspunktet i stedet for at stole på runtime-tjek eller affaldsindsamling.