Útmutató Rust rettenthetetlen egyidejűségéhez

A párhuzamosság egy program azon képessége, hogy egyszerre több feladatot is végrehajtson ugyanazon a CPU magon. Az egyidejű feladatok átfedésben futnak és fejeződnek be meghatározott sorrend nélkül, ellentétben a párhuzamossággal, ahol ugyanazon feladat különböző feladatai vagy részfeladatai futnak egyszerre több hardveren processzorok.

A Rust kiemelkedik teljesítményjellemzőivel és a párhuzamosság biztonságos és hatékony támogatásával. Rust párhuzamosság-szemlélete a "félelem nélküli párhuzamosság" koncepcióján alapul, ahol a nyelv célja, hogy megkönnyítse a biztonságos írást. egyidejű kód a tulajdonosi és kölcsönzési rendszerén keresztül, amely szigorú szabályokat érvényesít a fordítási időben, hogy megakadályozza az adatok nyomait és biztosítja a memóriát biztonság.

Az egyidejűség megértése rozsdában

A Rust számos párhuzamossági primitívet biztosít párhuzamos programok írásához, beleértve a szálakat, az üzenettovábbítást, a mutexet, az atomtípusokat és az aszinkron/várakozást az aszinkron programozáshoz.

Íme egy áttekintés a Rust egyidejűségi primitíveiről:

1. Szálak: A rozsda biztosítja a std:: szál modult a szabványos könyvtárában a szálak létrehozásához és kezeléséhez. Új szálakat hozhat létre a szál:: spawn funkció. A szál:: spawn a kódot tartalmazó lezárást veszi a végrehajtáshoz. Olyan szálakat is futtathat, amelyek párhuzamosan futhatnak, és a Rust szinkronizálási primitíveket biztosít a végrehajtásuk koordinálásához. A kölcsönellenőrző biztosítja, hogy a hivatkozások ne vezessenek váratlan viselkedéshez.
2. Üzenet átadása: A Rust párhuzamossági modellje támogatja a szálak közötti üzenettovábbítást. A következőn keresztül megvalósított csatornákat fogja használni std:: szinkronizálás:: mpsc modul az üzenettovábbításhoz. Egy csatorna egy adóból áll (Feladó) és egy vevő (Vevő). A szálak üzeneteket küldhetnek az adón keresztül, és fogadhatják azokat a vevőn keresztül. Ez biztonságos és szinkronizált módot biztosít a szálak közötti kommunikációhoz.
3. Mutexek és atomtípusok: A Rust szinkronizációs primitíveket biztosít, beleértve a mutexet (std:: szinkronizálás:: Mutex) és atomi típusok (std:: szinkron:: atomi), kizárólagos adatmegosztási hozzáférés biztosítása érdekében. A mutexek lehetővé teszik több szál számára, hogy egyidejűleg hozzáférjenek az adatokhoz, miközben megakadályozzák az adatversenyeket. Az atomi típusok atomi műveleteket tesznek lehetővé megosztott adatokon, például számláló növelését anélkül, hogy kifejezett zárolást igényelnének.
4. Async/Await and Futures: Rozsda async/várja A szintaxis egyidejűleg végrehajtható aszinkron kód írásának funkcióját biztosítja. Az aszinkron programok hatékonyan kezelik az I/O-hoz kötött feladatokat, lehetővé téve a programok számára, hogy más feladatokat hajtsanak végre, miközben más I/O műveletekre várnak. Rozsdáé async/várja szintaxisa határidős ügyleteken alapul, és ezeket a következővel tudja működtetni async-std vagy tokio futásidejű könyvtárak.

A rozsdás szálak könnyűek, és a futási idő hiánya miatt kiválóan alkalmasak nagy teljesítményű alkalmazásokhoz. A Rust párhuzamossági primitívei zökkenőmentesen integrálódnak több könyvtárba és keretrendszerbe a különböző párhuzamossági igényekhez.

A Spawn szálak használata Rustban

Használni fogod a std:: szál modul a szálak létrehozásához. A std:: szál:: spawn A funkció lehetővé teszi egy új szál létrehozását, amely a fő szállal vagy a program bármely más meglévő szálával párhuzamosan fut.

Így hozhat létre szálat a std:: szál:: spawn funkció:

használat std:: menet;
fnfő-() {
// Új szál létrehozása
hagyja thread_handle = szál:: spawn(|| {
// Az új szálban végrehajtott kód ide kerül
println!(– Üdvözlet az új szálból!);
 });
// Várja meg, amíg a létrehozott szál befejeződik
 thread_handle.join().unwrap();
// A főszálban végrehajtott kód itt folytatódik
println!(– Üdvözlet a főszálból!);
}

A fő- függvény új szálat hoz létre a szál:: spawn függvényt a szálban a végrehajtás kódját tartalmazó lezárás átadásával (ebben az esetben a lezárás névtelen függvény). A lezárás egy üzenetet nyomtat, amely jelzi, hogy az új szál fut.

A csatlakozik módszer a thread_handle lehetővé teszi, hogy a fő szál megvárja, amíg a létrehozott szál befejezi a végrehajtást. Hívással csatlakozik, a funkció biztosítja, hogy a főszál megvárja, amíg a létrehozott szál befejeződik, mielőtt folytatná.

Több szálat is létrehozhat, és hurkot vagy bármilyen mást használhat Rozsdamentesítő szerkezet hogy mindegyikhez több lezárást és spawn szálat hozzon létre.

használat std:: menet;
fnfő-() {
hagyja szálak_száma = 5;
hagyjamut thread_handles = vec![];
számára én ban ben0..szálak_száma {
hagyja thread_handle = szál:: spawn(mozog || {
println!("Üdvözöljük a(z) {} szálból", i);
 });
 thread_handles.push (thread_handle);
 }
számára fogantyú ban ben thread_handles {
 handle.join().unwrap();
 }
println!("Minden szál befejeződött!");
}

A for ciklus öt szálat hoz létre, amelyek mindegyike egyedi azonosítóhoz van rendelve én a ciklusváltozóval. A lezárások rögzítik az értékét én a... val mozog elkerülendő kulcsszó tulajdonosi kérdések, és a thread_handles vektor tárolja a szálakat későbbi használatra csatlakozik hurok.

Az összes szál ívása után a fő- függvény ismétlődik a thread_handles vektor, hívások csatlakozik minden egyes fogantyún, és megvárja, amíg az összes szál végrehajtódik.

Üzenetek továbbítása csatornákon keresztül

Az üzeneteket csatornákkal rendelkező szálakon keresztül továbbíthatja. A Rust funkciót biztosít az üzenetek átadásához std:: szinkronizálás:: mpsc modult. Itt, mpsc A "több termelő, egyetlen fogyasztó" rövidítése, és több szál közötti kommunikációt tesz lehetővé azáltal, hogy üzeneteket küld és fogad csatornákon keresztül.

A következőképpen valósíthatja meg az üzenettovábbítást a szálak közötti kommunikáció csatornáin a programjaiban:

használat std:: szinkronizálás:: mpsc;
használat std:: menet;
fnfő-() {
// Csatorna létrehozása
hagyja (küldő, vevő) = mpsc:: csatorna();
// Nyomj szálat
 szál:: spawn(mozog || {
// Üzenet küldése a csatornán keresztül
 küldő.küld(– Üdvözlet a cérnából!).kibont();
 });
// Az üzenet fogadása a főszálban
hagyja fogadott_üzenet = fogadó.recv().unwrap();
println!("Kapott üzenet: {}", fogadott_üzenet);
}

A fő- funkcióval csatornát hoz létre mpsc:: channel() amely visszaadja a feladó és a vevő. A feladó üzeneteket küld a vevő amely fogadja az üzeneteket. A fő- függvény továbblép a szálak spawnjává, és áthelyezi a tulajdonjogát Feladó a menetzárhoz. A menetzár belsejében a feladó.küld() funkció üzenetet küld a csatornán keresztül.

A Receiver.recv() függvény fogadja az üzenetet a végrehajtás leállításával, amíg a szál meg nem kapja az üzenetet. A fő- funkció sikeres üzenetfogadás után kinyomtatja az üzenetet a konzolra.

Ne feledje, hogy az üzenet csatornán keresztüli küldése felemészti a feladót. Ha több szálból kell üzeneteket küldenie, klónozhatja a feladót a feladó.klón() funkció.

Ezenkívül a mpsc modul más módszereket is biztosít, mint pl try_recv(), amely nem blokkolva próbál üzenetet fogadni, és iter(), amely egy iterátort hoz létre a fogadott üzenetek felett.

A csatornákon keresztüli üzenettovábbítás biztonságos és kényelmes módot biztosít a szálak közötti kommunikációra, miközben elkerüli az adatversenyeket és biztosítja a megfelelő szinkronizálást.

A Rust tulajdonjoga és kölcsönzési modellje garantálja a memória biztonságát

A Rust egyesíti a tulajdonjogot, a kölcsönzést és a kölcsönzés-ellenőrzőt, hogy robusztus, biztonságos, párhuzamos programozási keretet biztosítson.

A kölcsönzés-ellenőrző biztonsági hálóként működik, és a fordítási időben észleli a lehetséges problémákat, nem pedig a futásidejű ellenőrzésekre vagy a szemétgyűjtésre hagyatkozik.