Bevezetés az aszinkron programozásba Rustban

A hagyományos szinkron programozási modellek gyakran vezetnek teljesítménybeli szűk keresztmetszetek kialakulásához. Ennek az az oka, hogy a program megvárja a lassú műveletek befejezését, mielőtt a következő feladatra lépne. Ez gyakran rossz erőforrás-felhasználást és lassú felhasználói élményt eredményez.

Az aszinkron programozás lehetővé teszi, hogy olyan nem blokkoló kódot írjon, amely hatékonyan használja fel a rendszer erőforrásait. Az aszinkron programozás kihasználásával több feladatot is végrehajtó alkalmazásokat tervezhet. Az aszinkron programozás számos hálózati kérés kezeléséhez vagy nagy mennyiségű adat feldolgozásához praktikus a végrehajtási folyamat blokkolása nélkül.

Aszinkron programozás Rustban

A Rust aszinkron programozási modellje lehetővé teszi írjon hatékony Rust kódot, amely párhuzamosan fut a végrehajtási folyamat blokkolása nélkül. Az aszinkron programozás előnyös I/O műveletek, hálózati kérések és külső erőforrásokra való várakozással járó feladatok kezelésekor.

Az aszinkron programozást a Rust alkalmazásaiban többféleképpen is megvalósíthatja. Ide tartoznak a nyelvi funkciók, a könyvtárak és a Tokio futtatókörnyezet.

Is, Rust tulajdonosi modellje és a párhuzamossági primitívek, mint a csatornák és zárak biztonságos és hatékony párhuzamos programozást tesznek lehetővé. Ezeket a funkciókat aszinkron programozással kihasználhatja olyan párhuzamos rendszerek létrehozásához, amelyek jól skálázhatók és több CPU-magot használnak.

Rust aszinkron programozási koncepciói

A Futures alapot ad az aszinkron programozáshoz a Rustban. A jövő egy aszinkron számítást jelent, amelyet még nem hajtottak végre teljesen.

A határidős ügyletek lusták (csak szavazáskor hajtják végre őket). Amikor jövőt hívsz közvélemény kutatás() módszerrel ellenőrzi, hogy a jövő elkészült-e, vagy további munkára van szüksége. Ha a jövő nincs készen, akkor visszatér Szavazás:: Függőben, jelezve, hogy a feladatot későbbi végrehajtásra kell ütemezni. Ha a jövő készen áll, visszatér Szavazás:: Kész a kapott értékkel.

A Rust szabványos eszközlánca aszinkron I/O primitíveket, a fájl I/O aszinkron verzióját, hálózatot és időzítőket tartalmaz. Ezek a primitívek lehetővé teszik az I/O műveletek aszinkron végrehajtását. Ez segít elkerülni a program végrehajtásának blokkolását, miközben az I/O feladatok befejezésére vár.

Az aszinkron/várakozás szintaxis lehetővé teszi a szinkron kódhoz hasonló aszinkron kód írását. Ez intuitívvá és könnyen karbantarthatóvá teszi a kódot.

A Rust aszinkron programozási megközelítése a biztonságot és a teljesítményt hangsúlyozza. A tulajdonlási és kölcsönzési szabályok biztosítják a memória biztonságát és megakadályozzák a gyakori párhuzamossági problémákat. Az aszinkron/várakozó szintaxis és a határidők intuitív módon fejezik ki az aszinkron munkafolyamatokat. Használhat harmadik féltől származó futtatókörnyezetet a feladatok kezeléséhez a hatékony végrehajtás érdekében.

Kombinálhatja ezeket a nyelvi funkciókat, könyvtárakat és futási környezetet, hogy nagy teljesítményű kódot írjon. Erőteljes és ergonomikus keretet biztosít az aszinkron rendszerek építéséhez. Emiatt a Rust népszerű választás az I/O-hoz kötött feladatok hatékony kezelését és nagy párhuzamosságot igénylő projektekhez.

A Rust 1.39-es és újabb verziói nem támogatják az aszinkron műveleteket a Rust szabványos könyvtárában. A használatához szüksége lesz egy harmadik féltől származó ládára async/várja szintaxis az aszinkron műveletek kezeléséhez a Rustban. Használhat harmadik féltől származó csomagokat, mint pl Tokio vagy async-std az async/await szintaxis használatához.

Aszinkron programozás Tokióval

A Tokio egy robusztus aszinkron futtatókörnyezet a Rust számára. Funkciókat biztosít nagy teljesítményű és méretezhető alkalmazások létrehozásához. Kiaknázhatja az aszinkron programozás erejét Tokióval. Bővíthetőséget is biztosít.

A Tokio középpontjában az aszinkron feladatütemezési és végrehajtási modell áll. A Tokio lehetővé teszi, hogy aszinkron kódot írjon az async/await szintaxissal. Ez lehetővé teszi a rendszer erőforrásainak hatékony kihasználását és a feladatok egyidejű végrehajtását. Tokio eseményhuroka hatékonyan kezeli a feladatok ütemezését. Ez biztosítja a CPU magok optimális kihasználását, és minimalizálja a környezetváltási többletterhelést.

A Tokio kombinátorai megkönnyítik a feladatok koordinálását és összeállítását. A Tokio hatékony koordinációs és kompozíciós eszközöket biztosít. A csatlakozással megvárhatja több feladat elvégzését, kiválasztással kiválaszthatja az első befejezett feladatot, és versenyzéssel versenyezhet egymással.

Add hozzá a tokio láda a tiédhez Cargo.toml fájl függőségei szakaszban.

[dependencies]
tokio = { version = "1.9", features = ["full"] }

A következőképpen használhatja az aszinkron/várakozás szintaxist a Rust programjaiban Tokióval:

use tokio:: time:: sleep;
use std:: time:: Duration;
asyncfnhello_world() {
println!("Hello, ");
 sleep(Duration:: from_secs(1)).await;
println!("World!");
}
#[tokio:: main]
asyncfnmain() {
 hello_world().await;
}

A Helló Világ funkció aszinkron, így használhatja a várja kulcsszó a végrehajtás szüneteltetéséhez, amíg egy jövőt meg nem oldanak. A Helló Világ függvény nyomtat "Helló, " a konzolhoz. A Időtartam:: from_sec (1) függvényhívás egy másodpercre felfüggeszti a függvény végrehajtását. A várja kulcsszó az alvási jövő befejezésére vár. Végül a Helló Világ függvény nyomtat "Világ!" a konzolhoz.

A fő- függvény aszinkron függvény a #[tokio:: fő] tulajdonság. Ez a fő funkciót jelöli ki a Tokio futási környezet belépési pontjaként. A hello_world().várj a hello_world függvényt aszinkron módon hajtja végre.

Feladatok késleltetése Tokióval

Az aszinkron programozásban elterjedt feladat a késleltetések vagy a feladatok ütemezése egy meghatározott időtartományban történő futtatáshoz. A tokio futási idő mechanizmust biztosít az aszinkron időzítők és késleltetések használatához a tokio:: idő modult.

Így késleltetheti a műveletet a Tokio futási környezettel:

use std:: time:: Duration;
use tokio:: time:: sleep;
asyncfndelayed_operation() {
println!("Performing delayed operation...");
 sleep(Duration:: from_secs(2)).await;
println!("Delayed operation completed.");
}
#[tokio:: main]
asyncfnmain() {
println!("Starting...");
 delayed_operation().await;
println!("Finished.");
}

A késleltetett_művelet funkció két másodperces késleltetést vezet be a alvás módszer. A késleltetett_művelet függvény aszinkron, így a await segítségével szüneteltetheti a végrehajtást, amíg a késleltetés be nem fejeződik.

Hibakezelés aszinkron programokban

Az aszinkron Rust kód hibakezelése magában foglalja a Eredmény típus és Rozsdahibák kezelése a... val ? operátor.

use tokio:: fs:: File;
use tokio:: io;
use tokio:: io::{AsyncReadExt};
asyncfnread_file_contents() -> io::Result<String> {
letmut file = File:: open("file.txt").await?;
letmut contents = String::new();
 file.read_to_string(&mut contents).await?;
Ok(contents)
}
asyncfnprocess_file() -> io::Result {
let contents = read_file_contents().await?;
// Process the file contents
Ok(())
}
#[tokio:: main]
asyncfnmain() {
match process_file().await {
Ok(()) => println!("File processed successfully."),
Err(err) => eprintln!("Error processing file: {}", err),
 }
}

A read_file_contents függvény egy io:: Eredmény ami egy I/O hiba lehetőségét jelenti. Használatával a ? operátort minden aszinkron művelet után, a Tokio futtatókörnyezet továbbítja a hibákat a hívási veremben.

A fő- függvény az eredményt a-val kezeli mérkőzés utasítás, amely a művelet eredménye alapján szöveget nyomtat.

A Reqwest aszinkron programozást használ a HTTP műveletekhez

Sok népszerű láda, köztük a Reqwest, a Tokiot használja az aszinkron HTTP műveletek biztosítására.

A Tokiot használhatja a Reqwest-tel, hogy több HTTP-kérést küldjön anélkül, hogy blokkolna más feladatokat. A Tokio segíthet több ezer párhuzamos kapcsolat kezelésében és az erőforrások hatékony kezelésében.