Rooste kartmatu samaaegsuse juhend

Samaaegsus on programmi võime täita mitut ülesannet samaaegselt samas CPU tuumas. Samaaegsed ülesanded käitatakse ja täidetakse kattuva aja jooksul ilma määratud järjestuseta, erinevalt paralleelsusest, kus sama ülesande erinevad ülesanded või alamülesanded töötavad korraga riistvaras, millel on mitu protsessorid.

Rust paistab silma oma jõudlusomaduste ja samaaegsuse toetamise poolest turvalisel ja tõhusal viisil. Rusti lähenemine samaaegsusele põhineb "kartmatu samaaegsuse" kontseptsioonil, kus keele eesmärk on muuta ohutu kirjutamise lihtsaks. samaaegne kood oma omandi- ja laenusüsteemi kaudu, mis jõustab kompileerimise ajal ranged reeglid, et vältida andmete jälgi ja tagada mälu ohutus.

Samaaegsuse mõistmine roostes

Rust pakub samaaegsete programmide kirjutamiseks mitmeid samaaegsusprimitiive, sealhulgas lõime, sõnumite edastamist, mutexe, aatomitüüpe ja asünkroonse programmeerimise asünkrooni/ootmist.

Siin on ülevaade Rusti samaaegsuse primitiividest:

1. Niidid: Rooste pakub a std:: niit moodul oma standardses teegis lõimede loomiseks ja haldamiseks. Saate luua uusi lõime rakendusega niit:: kudema funktsiooni. The niit:: kudema võtab täitmiseks koodi sisaldava sulguri. Saate käivitada ka lõime, mis võivad töötada paralleelselt, ja Rust pakub nende täitmise koordineerimiseks sünkroonimisprimitiive. Laenu kontrollija tagab, et viited ei too kaasa ootamatut käitumist.
2. Sõnumi edastamine: Rusti samaaegsusmudel toetab sõnumite edastamist lõimede vahel. Kasutate selle kaudu juurutatud kanaleid std:: sünkroonimine:: mpsc moodul sõnumite edastamiseks. Kanal koosneb saatjast (Saatja) ja vastuvõtja (Vastuvõtja). Lõimed võivad saata sõnumeid saatja kaudu ja vastu võtta vastuvõtja kaudu. See tagab turvalise ja sünkroonitud viisi lõimede vahel suhtlemiseks.
3. Muteksid ja aatomitüübid: Rust pakub sünkroonimisprimitiive, sealhulgas mutexe (std:: sync:: Mutex) ja aatomitüübid (std:: sync:: atomic), et tagada eksklusiivne juurdepääs andmete jagamisele. Muteksid võimaldavad mitmel lõimel samaaegselt andmetele juurde pääseda, vältides samal ajal andmejooksu. Aatomitüübid pakuvad jagatud andmetega aatomioperatsioone, näiteks loenduri suurendamist, ilma selgesõnalist lukustamist nõudmata.
4. Async/Await ja Futures: Rooste oma asünkr/ootama süntaks pakub funktsioone asünkroonse koodi kirjutamiseks, mida saate samaaegselt käivitada. Asünkroonsed programmid tegelevad tõhusalt I/O-ga seotud ülesannetega, võimaldades programmidel täita muid ülesandeid, oodates teisi I/O-toiminguid. Rooste oma asünkr/ootama süntaks põhineb futuuridel ja saate neid toita async-std või tokio käitusaegsed raamatukogud.

Roosteniidid on kerged ja tööaja lisakulude puudumine muudab need hästi sobivaks suure jõudlusega rakenduste jaoks. Rusti samaaegsuse primitiivid integreeruvad sujuvalt mitme teegi ja raamistikuga erinevate samaaegsuse vajaduste jaoks.

Kuidas kasutada kudemisniite roostes

Sa kasutad std:: niit moodul lõimede loomiseks. The std:: niit:: kudema Funktsioon võimaldab teil luua uue lõime, mis töötab samaaegselt põhilõime või mõne muu programmi olemasoleva lõimega.

Siit saate teada, kuidas saate lõime luua std:: niit:: kudema funktsioon:

kasutada std:: niit;
fnpeamine() {
// Loo uus lõime
lase thread_handle = lõime:: spawn(|| {
// Uues lõimes käivitatud kood läheb siia
println!("Tere uuest lõimest!");
 });
// Oodake, kuni tekkinud lõng lõpeb
 thread_handle.join().unwrap();
// Põhilõimes käivitatud kood jätkub siin
println!("Tere pealõngast!");
}

The peamine funktsioon loob funktsiooniga uue lõime niit:: kudema funktsioon, edastades lõimes täitmise koodi sisaldava sulgemise (sel juhul on sulgemine anonüümne funktsioon). Sulgemine prindib teate, mis näitab, et uus lõim töötab.

The liituda meetodil niidi_käepide võimaldab põhilõimel oodata, kuni loodud lõime täitmise lõpetab. Helistades liituda, tagab funktsioon, et põhilõim ootab enne jätkamist, kuni loodud lõim on lõpule viidud.

Saate luua mitu lõime ja kasutada silmust või mõnda muud Roostetõrje struktuur luua mitu sulgemist ja luua igaühe jaoks lõime.

kasutada std:: niit;
fnpeamine() {
lase lõimede_arv = 5;
lasemut niidi_käepidemed = vec![];
jaoks i sisse0..lõimede_arv {
lase thread_handle = lõime:: spawn(liigutada || {
println!("Tere lõimest {}", i);
 });
 thread_handles.push (thread_handle);
 }
jaoks käepide sisse thread_handles {
 hand.join().unwrap();
 }
println!("Kõik lõimed lõppenud!");
}

For-silmus loob viis lõime, millest igaühele on määratud kordumatu identifikaator i tsükli muutujaga. Sulgemised kajastavad väärtust i koos liigutada märksõna, mida vältida omandiküsimused, ja niidi_käepidemed vektor salvestab lõimed hilisemaks kasutamiseks liituda silmus.

Pärast kõigi niitide kudemist, peamine funktsioon kordab üle niidi_käepidemed vektor, kõned liituda igal käepidemel ja ootab, kuni kõik lõimed käivituvad.

Sõnumite edastamine kanalite kaudu

Saate sõnumeid edastada kanalitega lõimede kaudu. Rust pakub funktsiooni sõnumite edastamiseks std:: sünkroonimine:: mpsc moodul. Siin mpsc tähistab "mitu tootjat, üks tarbija" ja see võimaldab suhelda mitme lõime vahel, saates ja vastu võtta sõnumeid kanalite kaudu.

Siit saate teada, kuidas saate oma programmides rakendada sõnumite edastamist lõimedevahelise suhtluse kanalite kaudu.

kasutada std:: sünkroonimine:: mpsc;
kasutada std:: niit;
fnpeamine() {
// Looge kanal
lase (saatja, vastuvõtja) = mpsc:: kanal();
// Loo niit
 lõim:: spawn(liigutada || {
// Saada sõnum läbi kanali
 sender.send("Tere niidist!").unwrap();
 });
// Saate sõnumi põhilõimes vastu võtta
lase vastuvõetud_sõnum = vastuvõtja.recv().unwrap();
println!("Saadud sõnum: {}", saadud_sõnum);
}

The peamine funktsioon loob kanali mpsc:: kanal () mis tagastab a saatja ja a vastuvõtja. The saatja saadab sõnumeid aadressile vastuvõtja kes sõnumeid vastu võtab. The peamine funktsioon jätkab lõimede loomist ja omandiõiguse teisaldamist Saatja keerme sulguri külge. Keerme sulguri sees on saatja.send() funktsioon saadab kanali kaudu sõnumi.

The Receiver.recv() funktsioon võtab teate vastu, peatades täitmise, kuni lõim on sõnumi vastu võtnud. The peamine funktsioon prindib pärast edukat sõnumi vastuvõtmist sõnumi konsooli.

Pange tähele, et sõnumi saatmine kanali kaudu kulutab saatjat. Kui teil on vaja sõnumeid saata mitmest lõimest, saate saatja kloonida käsuga saatja.kloon() funktsiooni.

Lisaks on mpsc moodul pakub muid meetodeid, nagu try_recv(), mis blokeerimata püüab sõnumit vastu võtta ja iter(), mis loob vastuvõetud sõnumitele iteraatori.

Kanalite kaudu sõnumite edastamine pakub turvalise ja mugava viisi lõimede vahel suhtlemiseks, vältides samal ajal andmejooksu ja tagades õige sünkroonimise.

Rusti omandi- ja laenumudel garanteerib mälu ohutuse

Rust ühendab omandiõiguse, laenamise ja laenukontrolli, et pakkuda tugevat, turvalist ja samaaegset programmeerimisraamistikku.

Laenukontroll toimib turvavõrguna, tuvastades võimalikud probleemid kompileerimise ajal, selle asemel, et tugineda käitusaegsetele kontrollidele või prügi kogumisele.