Vodnik po neustrašni sočasnosti Rusta

Sočasnost je zmožnost programa, da izvaja več nalog hkrati na istem jedru procesorja. Sočasna opravila se izvajajo in dokončajo v prekrivajočem se času brez določenega vrstnega reda, za razliko od vzporednosti, kjer se različne naloge ali podopravila iste naloge izvajajo hkrati na strojni opremi z več procesorji.

Rust izstopa po svojih zmogljivostnih funkcijah in podpori za sočasnost na varen in učinkovit način. Rustov pristop k sočasnosti temelji na konceptu »neustrašne sočasnosti«, kjer je cilj jezika olajšati varno pisanje sočasna koda prek sistema lastništva in izposoje, ki uveljavlja stroga pravila v času prevajanja, da prepreči sledi podatkov in zagotavlja pomnilnik varnost.

Razumevanje sočasnosti v Rustu

Rust ponuja več sočasnih primitivov za pisanje sočasnih programov, vključno z nitmi, posredovanjem sporočil, muteksi, atomskimi tipi in async/await za asinhrono programiranje.

Tukaj je pregled Rustovih primitivov za sočasnost:

1. Niti: Rust zagotavlja a std:: nit modul v svoji standardni knjižnici za ustvarjanje in upravljanje niti. Nove niti lahko ustvarite z nit:: spawn funkcijo. The nit:: spawn prevzame zaključek, ki vsebuje kodo za izvedbo. Zaženete lahko tudi niti, ki se lahko izvajajo vzporedno, Rust pa zagotavlja sinhronizacijske primitive za usklajevanje njihovega izvajanja. Kontrolor izposoje zagotavlja, da reference ne vodijo do nepričakovanega vedenja.
2. Posredovanje sporočil: Rustov model sočasnosti podpira prenos sporočil med nitmi. Uporabili boste kanale, implementirane prek std:: sync:: mpsc modul za posredovanje sporočil. Kanal je sestavljen iz oddajnika (Pošiljatelj) in sprejemnik (Sprejemnik). Niti lahko pošiljajo sporočila prek oddajnika in jih sprejemajo prek sprejemnika. To zagotavlja varen in sinhroniziran način komunikacije med nitmi.
3. Muteksi in atomski tipi: Rust zagotavlja primitive za sinhronizacijo, vključno z muteksi (std:: sync:: Mutex) in atomske vrste (std:: sync:: atomic), da se zagotovi ekskluzivni dostop do skupne rabe podatkov. Muteksi omogočajo več nitim hkratni dostop do podatkov, hkrati pa preprečujejo dirkanje podatkov. Atomski tipi zagotavljajo atomske operacije na podatkih v skupni rabi, kot je povečanje števca, ne da bi zahtevali izrecno zaklepanje.
4. Async/Await in Futures: Rustovo asinh/čakati sintaksa zagotavlja funkcionalnost za pisanje asinhrone kode, ki jo lahko izvajate sočasno. Asinhroni programi se učinkovito ukvarjajo z nalogami, vezanimi na V/I, kar programom omogoča izvajanje drugih nalog, medtem ko čakajo na druge V/I operacije. Rustovo asinh/čakati sintaksa temelji na terminskih pogodbah in jih lahko poganjate z async-std oz tokio izvajalne knjižnice.

Niti Rust so lahke in zaradi odsotnosti režijskih stroškov med izvajanjem so zelo primerne za visoko zmogljive aplikacije. Rustove primitive za sočasnost se neopazno integrirajo z več knjižnicami in ogrodji za različne potrebe po sočasnosti.

Kako uporabljati Spawn Threads v Rust

Uporabili boste std:: nit modul za ustvarjanje niti. The std:: thread:: spawn vam omogoča, da ustvarite novo nit, ki se bo izvajala sočasno z glavno nitjo ali katero koli drugo obstoječo nitjo v vašem programu.

Tukaj je opisano, kako lahko ustvarite nit z std:: thread:: spawn funkcija:

uporaba std:: nit;
fnglavni() {
// Ustvari novo nit
pustiti thread_handle = thread:: spawn(|| {
// Koda, izvedena v novi niti, gre sem
println!("Pozdrav iz nove teme!");
 });
// Počakajte, da se sprožena nit konča
 thread_handle.join().unwrap();
// Koda, izvedena v glavni niti, se nadaljuje tukaj
println!("Pozdravljeni iz glavne teme!");
}

The glavni funkcija ustvari novo nit z nit:: spawn funkcijo s posredovanjem zaprtja, ki vsebuje kodo za izvedbo v niti (v tem primeru je zaprtje anonimna funkcija). Zaprtje natisne sporočilo, ki kaže, da se nova nit izvaja.

The pridruži se metoda na ročaj_nit omogoča glavni niti, da počaka, da sprožena nit zaključi izvedbo. S klicem pridruži se, funkcija zagotovi, da glavna nit počaka, da se sprožena nit zaključi, preden nadaljuje.

Ustvarite lahko več niti in uporabite zanko ali katero koli drugo Struktura za nadzor rje za ustvarjanje več zaprtij in ustvarjanje niti za vsako.

uporaba std:: nit;
fnglavni() {
pustiti num_threads = 5;
pustitimut ročaji_nitk = vec![];
za jaz v0..num_threads {
pustiti thread_handle = thread:: spawn(premakniti || {
println!("Pozdrav iz niti {}", jaz);
 });
 thread_handles.push (thread_handle);
 }
za ročaj v ročaji_nitk {
 handle.join().unwrap();
 }
println!("Vse niti so končane!");
}

Zanka for ustvari pet niti, od katerih je vsaka dodeljena edinstvenemu identifikatorju jaz s spremenljivko zanke. Zapirala zajemajo vrednost jaz z premakniti ključna beseda, ki se ji je treba izogibati lastninska vprašanja, in ročaji_nitk vektor shrani niti za pozneje v pridruži se zanka.

Po ustvarjanju vseh niti je glavni funkcija ponavlja čez ročaji_nitk vektor, klici pridruži se na vsakem ročaju in čaka na izvedbo vseh niti.

Prenos sporočil skozi kanale

Sporočila lahko posredujete prek niti s kanali. Rust zagotavlja funkcionalnost za posredovanje sporočil v std:: sync:: mpsc modul. tukaj, mpsc pomeni "več proizvajalcev, en potrošnik" in omogoča komunikacijo med več niti s pošiljanjem in prejemanjem sporočil prek kanalov.

Tukaj je opisano, kako v svojih programih implementirate prenos sporočil skozi kanale komunikacije med nitmi:

uporaba std:: sync:: mpsc;
uporaba std:: nit;
fnglavni() {
// Ustvarite kanal
pustiti (pošiljatelj, prejemnik) = mpsc:: kanal();
// Ustvari nit
 nit:: spawn(premakniti || {
// Pošljite sporočilo prek kanala
 pošiljatelj.pošlji("Pozdravljeni iz teme!").unwrap();
 });
// Prejmi sporočilo v glavni niti
pustiti prejeto_sporočilo = receiver.recv().unwrap();
println!("Prejeto sporočilo: {}", prejeto_sporočilo);
}

The glavni funkcija ustvari kanal z mpsc:: kanal() ki vrne a pošiljatelj in a sprejemnik. The pošiljatelj pošilja sporočila na sprejemnik ki sprejema sporočila. The glavni funkcija nadaljuje z ustvarjanjem niti in prenosom lastništva nad Pošiljatelj do zaprtja niti. Znotraj navojnega zapirala, pošiljatelj.send() funkcija pošlje sporočilo prek kanala.

The receiver.recv() funkcija sprejme sporočilo tako, da ustavi izvajanje, dokler nit ne prejme sporočila. The glavni funkcija natisne sporočilo na konzolo po uspešnem prejemu sporočila.

Upoštevajte, da pošiljanje sporočila prek kanala porabi pošiljatelja. Če morate poslati sporočila iz več niti, lahko klonirate pošiljatelja z sender.clone() funkcijo.

Poleg tega je mpsc modul ponuja druge metode, npr poskusi_recv(), ki neblokira poskuša prejeti sporočilo, ter iter(), ki ustvari iterator nad prejetimi sporočili.

Prenos sporočil prek kanalov zagotavlja varen in priročen način komunikacije med nitmi, hkrati pa se izogne ​​podatkovnim tekmam in zagotovi ustrezno sinhronizacijo.

Rustov model lastništva in izposoje zagotavlja varnost pomnilnika

Rust združuje lastništvo, izposojo in preverjalnik izposoje, da zagotovi robustno, varno in sočasno programsko ogrodje.

Preverjevalnik izposoje deluje kot varnostna mreža, saj zazna morebitne težave v času prevajanja, namesto da bi se zanašal na preverjanja med izvajanjem ali zbiranje smeti.