Ymmärrä Rustin lähestymistapa samanaikaisuuteen, joka perustuu "peloton samanaikaisuuden" käsitteeseen.

Samanaikaisuus on ohjelman kykyä suorittaa useita tehtäviä samanaikaisesti samassa prosessoriytimessä. Samanaikaiset tehtävät suoritetaan ja valmistuvat päällekkäin ajassa ilman tiettyä järjestystä, toisin kuin rinnakkaisuus, jossa saman tehtävän eri tehtäviä tai alitehtäviä suoritetaan samanaikaisesti laitteistolla, jossa on useita prosessorit.

Rust erottuu suorituskykyominaisuuksistaan ​​ja tuesta samanaikaiselle turvalliselle ja tehokkaalle tavalla. Rustin lähestymistapa samanaikaisuuteen perustuu "peloton samanaikaisuuden" käsitteeseen, jossa kielen tavoitteena on tehdä turvallisesta kirjoittamisesta helppoa samanaikainen koodi omistus- ja lainausjärjestelmänsä kautta, joka noudattaa tiukat säännöt käännöshetkellä tietojen jäljityksen estämiseksi ja muistin varmistamiseksi turvallisuutta.

Samanaikaisuuden ymmärtäminen ruosteessa

Rust tarjoaa useita samanaikaisuusprimitiivejä samanaikaisten ohjelmien kirjoittamiseen, mukaan lukien säikeet, viestien välitys, mutexet, atomityypit ja asynkroninen ohjelmointi async/wait.

Tässä on yleiskatsaus Rustin samanaikaisuusprimitiiveistä:

  1. Kierteet: Rust tarjoaa a std:: lanka moduuli vakiokirjastossaan säikeiden luomista ja hallintaa varten. Voit luoda uusia säikeitä -sovelluksella lanka:: spawn toiminto. The lanka:: spawn ottaa koodin sisältävän sulkemisen suoritusta varten. Voit myös ajaa säikeitä, jotka voivat toimia rinnakkain, ja Rust tarjoaa synkronointiprimitiivit koordinoimaan niiden suorittamista. Lainauksen tarkistaja varmistaa, että viittaukset eivät johda odottamattomiin toimiin.
  2. Viestiä ohitetaan: Rustin samanaikaisuusmalli tukee viestien välittämistä säikeiden välillä. Käytät kautta toteutettuja kanavia std:: synkronointi:: mpsc moduuli viestien välittämiseen. Kanava koostuu lähettimestä (Lähettäjä) ja vastaanotin (Vastaanotin). Säikeet voivat lähettää viestejä lähettimen kautta ja vastaanottaa niitä vastaanottimen kautta. Tämä tarjoaa turvallisen ja synkronoidun tavan viestiä säikeiden välillä.
  3. Muteksit ja atomityypit: Rust tarjoaa synkronointiprimitiivit, mukaan lukien mutexet (std:: synkronointi:: Mutex) ja atomityypit (std:: synkronointi:: atomi), jotta varmistetaan yksinoikeus tietojen jakamiseen. Mutexet mahdollistavat useiden säikeiden pääsyn tietoihin samanaikaisesti ja estävät datakilpailun. Atomityypit tarjoavat atomioperaatioita jaetuille tiedoille, kuten laskurin kasvattamisen, ilman erityistä lukitsemista.
  4. Async/Await and Futures: Ruosteen asynk/odottaa syntaksi tarjoaa toiminnot asynkronisen koodin kirjoittamiseen, jonka voit suorittaa samanaikaisesti. Asynkroniset ohjelmat käsittelevät tehokkaasti I/O-sidottuja tehtäviä, jolloin ohjelmat voivat suorittaa muita tehtäviä odottaessaan muita I/O-toimintoja. Ruosteen asynk/odottaa syntaksi perustuu futuuriin, ja voit tehostaa niitä käyttämällä async-std tai tokio ajonaikaiset kirjastot.

Ruostelangat ovat kevyitä, ja ajonaikaisen ylärajan puuttuminen tekee niistä hyvin soveltuvia korkean suorituskyvyn sovelluksiin. Rustin samanaikaisuusprimitiivit integroituvat saumattomasti useisiin kirjastoihin ja kehyksiin erilaisiin samanaikaisuustarpeisiin.

Kuinka käyttää Spawn-säikeitä ruosteessa

Tulet käyttämään std:: lanka moduuli säikeiden synnyttämiseksi. The std:: lanka:: spawn -toiminnon avulla voit luoda uuden säikeen, joka toimii samanaikaisesti pääsäikeen tai muiden ohjelmassasi olevien säikeiden kanssa.

Näin voit luoda langan kanssa std:: lanka:: spawn toiminto:

käyttää std:: lanka;
fnpää() {
// Luo uusi ketju
antaa thread_handle = lanka:: spawn(|| {
// Uudessa säikeessä suoritettu koodi menee tähän
println!("Terve uudesta ketjusta!");
 });


// Odota syntyneen säikeen päättymistä
 thread_handle.join().unwrap();
// Pääsäikeessä suoritettu koodi jatkuu tästä
println!("Tervehdys pääketjusta!");
}

The pää -toiminto luo uuden säikeen lanka:: spawn funktio välittämällä sulkemisen, joka sisältää koodin suoritukseen säikeessä (tässä tapauksessa sulkeminen on anonyymi toiminto). Sulkeminen tulostaa viestin, joka ilmoittaa, että uusi säie on käynnissä.

The liittyä seuraan menetelmällä thread_handle antaa pääsäikeen odottaa syntyneen säikeen suorittamisen loppuun. Soittamalla liittyä seuraan, toiminto varmistaa, että pääsäie odottaa syntyneen säikeen valmistumista ennen jatkamista.

Voit luoda useita lankoja ja käyttää silmukkaa tai mitä tahansa muuta Ruosteenestorakenne luodaksesi useita sulkemisia ja luodaksesi säikeitä kullekin.

käyttää std:: lanka;
fnpää() {
antaa lankojen_määrä = 5;


antaamut thread_handles = vec![];


varten i sisään0..num_threads {
antaa thread_handle = lanka:: spawn(liikkua || {
println!("Hei ketjusta {}", i);
 });
 thread_handles.push (thread_handle);
 }


varten kahva sisään thread_handles {
 hand.join().unwrap();
 }
println!("Kaikki langat päättyneet!");
}

For-silmukka synnyttää viisi säiettä, joista jokaiselle on määritetty yksilöllinen tunniste i silmukkamuuttujan kanssa. Sulkeminen vangitsee arvon i kanssa liikkua vältettävä avainsana omistusasioita, ja thread_handles vektori tallentaa säikeet myöhempää käyttöä varten liittyä seuraan silmukka.

Kun kaikki langat on syntynyt, pää toiminto toistuu thread_handles vektori, puhelut liittyä seuraan jokaisessa kahvassa ja odottaa, että kaikki säikeet suoritetaan.

Viestien välittäminen kanavien kautta

Voit välittää viestejä kanavien kautta. Rust tarjoaa toimintoja viestien välittämiseen std:: synkronointi:: mpsc moduuli. Tässä, mpsc tarkoittaa "multiple tuottaja, yksi kuluttaja" ja se mahdollistaa viestinnän useiden säikeiden välillä lähettämällä ja vastaanottamalla viestejä kanavien kautta.

Näin toteutat viestien välityksen säikeiden välisen viestinnän kanavien kautta ohjelmissasi:

käyttää std:: synkronointi:: mpsc;
käyttää std:: lanka;
fnpää() {
// Luo kanava
antaa (lähettäjä, vastaanottaja) = mpsc:: kanava();


// Luo lanka
 lanka:: spawn(liikkua || {
// Lähetä viesti kanavan kautta
 lähettäjä.lähetä("Terve langalta!").unwrap();
 });
// Vastaanota viesti pääketjussa
antaa vastaanotettu_viesti = vastaanotin.recv().unwrap();
println!("Vastaanotettu viesti: {}", vastaanotettu_viesti);
}

The pää toiminto luo kanavan mpsc:: kanava() joka palauttaa a lähettäjä ja a vastaanotin. The lähettäjä lähettää viestejä osoitteeseen vastaanotin joka vastaanottaa viestit. The pää toiminto etenee poikimaan säikeitä ja siirtämään omistuksen Lähettäjä langan sulkemiseen. Kierresulkimen sisällä lähettäjä.lähetä() toiminto lähettää viestin kanavan kautta.

The vastaanotin.recv() toiminto vastaanottaa viestin pysäyttämällä suorituksen, kunnes säie on vastaanottanut viestin. The pää toiminto tulostaa viestin konsoliin onnistuneen viestin vastaanottamisen jälkeen.

Huomaa, että viestin lähettäminen kanavan kautta kuluttaa lähettäjää. Jos haluat lähettää viestejä useista säikeistä, voit kloonata lähettäjän komennolla lähettäjä.clone() toiminto.

Lisäksi, mpsc moduuli tarjoaa muita menetelmiä, kuten try_recv(), joka ei-esto yrittää vastaanottaa viestin, ja iter(), joka luo iteraattorin vastaanotettujen viestien päälle.

Viestien välittäminen kanavien kautta tarjoaa turvallisen ja kätevän tavan viestiä säikeiden välillä samalla, kun vältetään datakilpailut ja varmistetaan oikea synkronointi.

Rustin omistus- ja lainausmalli takaavat muistin turvallisuuden

Rust yhdistää omistajuuden, lainaamisen ja lainauksen tarkistuksen tarjotakseen vankan, turvallisen ja samanaikaisen ohjelmointikehyksen.

Lainaustarkistus toimii turvaverkkona, joka havaitsee mahdolliset ongelmat käännösvaiheessa sen sijaan, että luottaisi ajonaikaisiin tarkistuksiin tai roskien keräämiseen.