Modelele tradiționale de programare sincronă duc adesea la blocaje de performanță. Acest lucru se datorează faptului că programul așteaptă finalizarea operațiunilor lente înainte de a trece la următoarea sarcină. Acest lucru duce adesea la o utilizare slabă a resurselor și la o experiență de utilizator lentă.
Programarea asincronă vă permite să scrieți cod neblocant care utilizează eficient resursele sistemului. Folosind programarea asincronă, puteți proiecta aplicații care îndeplinesc mai multe sarcini. Programarea asincronă este utilă pentru gestionarea mai multor solicitări de rețea sau procesarea unor cantități mari de date fără a bloca fluxul de execuție.
Cuprins
Programare asincronă în Rust
Modelul de programare asincron al Rust vă permite să scrieți cod Rust eficient care rulează concomitent fără a bloca fluxul de execuție. Programarea asincronă este benefică atunci când se ocupă cu operațiuni I/O, solicitări de rețea și sarcini care implică așteptarea resurselor externe.
Puteți implementa programarea asincronă în aplicațiile dvs. Rust în mai multe moduri. Acestea includ caracteristici de limbă, biblioteci și timpul de execuție Tokio.
De asemenea, modelul de proprietate al lui Rust și primitivele de concurență, cum ar fi canalele și lacătele, permit programarea simultană sigură și eficientă. Puteți utiliza aceste funcții cu programare asincronă pentru a construi sisteme concurente care se scalează bine și utilizează mai multe nuclee CPU.
Conceptele de programare asincronă a lui Rust
Futures oferă o bază pentru programarea asincronă în Rust. Un viitor reprezintă un calcul asincron care nu a fost complet executat.
Futurile sunt leneșe (sunt executate doar atunci când sunt la sondaj). Când apelați o metodă future poll(), aceasta verifică dacă viitorul a fost finalizat sau dacă are nevoie de muncă suplimentară. Dacă viitorul nu este gata, returnează Poll::Pending, indicând că sarcina ar trebui programată pentru execuție ulterioară. Dacă viitorul este gata, returnează Poll::Ready cu valoarea rezultată.
Lanțul de instrumente standard al Rust include primitive I/O asincrone, o versiune asincronă a I/O fișierelor, rețele și temporizatoare. Aceste primitive vă permit să efectuați operațiuni I/O asincron. Acest lucru ajută la evitarea blocării execuției unui program în timp ce așteptați finalizarea sarcinilor I/O.
Sintaxa async/wait vă permite să scrieți cod asincron care arată similar cu codul sincron. Acest lucru face codul dvs. intuitiv și ușor de întreținut.
Abordarea Rust asupra programarii asincrone pune accent pe siguranta si performanta. Regulile de proprietate și de împrumut asigură siguranța memoriei și previn problemele comune de concurență. Sintaxa async/wait și futures oferă o modalitate intuitivă de a exprima fluxurile de lucru asincrone. Puteți utiliza un runtime terță parte pentru a gestiona sarcinile pentru o execuție eficientă.
Puteți combina aceste caracteristici de limbaj, biblioteci și runtime pentru a scrie cod de înaltă performanță. Oferă un cadru puternic și ergonomic pentru construirea de sisteme asincrone. Acest lucru face din Rust o alegere populară pentru proiectele care necesită o gestionare eficientă a sarcinilor legate de I/O și concurență ridicată.
Rust versiunea 1.39 și versiunile ulterioare nu acceptă operațiuni asincrone în biblioteca standard a Rust. Veți avea nevoie de o cutie terță parte pentru a utiliza sintaxa async/wait pentru a gestiona operațiunile asincrone în Rust. Puteți folosi pachete de la terți, cum ar fi Tokio sau async-std, pentru a lucra cu sintaxa async/wait.
Programare asincronă cu Tokio
Tokio este un timp de rulare asincron robust pentru Rust. Oferă funcționalitate pentru construirea de aplicații de înaltă performanță și scalabile. Puteți valorifica puterea programării asincrone cu Tokio. De asemenea, oferă caracteristici pentru extensibilitate.
La baza Tokio se află modelul său asincron de planificare și execuție a sarcinilor. Tokio vă permite să scrieți cod asincron cu sintaxa async/wait. Acest lucru permite utilizarea eficientă a resurselor sistemului și executarea concomitentă a sarcinilor. Bucla de evenimente Tokio gestionează eficient programarea sarcinilor. Acest lucru asigură utilizarea optimă a nucleelor CPU și minimizează suprasarcina de schimbare a contextului.
Combinatoarele Tokio facilitează coordonarea și compunerea sarcinilor. Tokio oferă instrumente puternice de coordonare și compunere a sarcinilor. Puteți aștepta ca mai multe sarcini să fie finalizate cu alăturare, selectați prima sarcină finalizată cu selectare și întreceți sarcinile unul împotriva celuilalt cu cursă.
Adăugați lada tokio la secțiunea de dependențe a fișierului Cargo.toml.
[dependencies]
tokio = { version = "1.9", features = ["full"] }
Iată cum puteți utiliza sintaxa async/wait în programele dvs. Rust cu Tokio:
use tokio::time::sleep;
use std::time::Duration;async fn hello_world() {
println!("Hello, ");
sleep(Duration::from_secs(1)).await;
println!("World!");
}#[tokio::main]
async fn main() {
hello_world().await;
}
Funcția hello_world este asincronă, așa că poate folosi cuvântul cheie await pentru a întrerupe execuția până când un viitor este rezolvat. Funcția hello_world afișează „Hello,” pe consolă. Apelul funcției Duration::from_secs(1) suspendă execuția funcției pentru o secundă. Cuvântul cheie await așteaptă să se finalizeze viitorul somn. În cele din urmă, funcția hello_world afișează „World!” la consolă.
Funcția principală este o funcție asincronă cu #[tokio::main] atribut. Acesta desemnează funcția principală ca punct de intrare pentru timpul de rulare Tokio. Hello_world().await execută funcția hello_world în mod asincron.
Întârzierea sarcinilor cu Tokio
O sarcină predominantă în programarea asincronă este utilizarea întârzierilor sau a sarcinilor de programare pentru a rula într-un interval de timp specificat. Tokio Runtime oferă un mecanism pentru utilizarea temporizatoarelor și întârzierilor asincrone prin modulul tokio::time.
Iată cum puteți întârzia o operație cu timpul de execuție Tokio:
use std::time::Duration;
use tokio::time::sleep;async fn delayed_operation() {
println!("Performing delayed operation...");
sleep(Duration::from_secs(2)).await;
println!("Delayed operation completed.");
}#[tokio::main]
async fn main() {
println!("Starting...");
delayed_operation().await;
println!("Finished.");
}
Funcția delayed_operation introduce o întârziere de două secunde cu metoda sleep. Funcția delayed_operation este asincronă, așa că poate folosi await pentru a întrerupe execuția până când întârzierea este completă.
Gestionarea erorilor în programele asincrone
Gestionarea erorilor în codul Rust asincron implică utilizarea tipului de rezultat și gestionarea erorilor Rust cu ? operator.
use tokio::fs::File;
use tokio::io;
use tokio::io::{AsyncReadExt};async fn read_file_contents() -> io::Result<String> {
let mut file = File::open("file.txt").await?;
let mut contents = String::new();
file.read_to_string(&mut contents).await?;
Ok(contents)
}async fn process_file() -> io::Result<()> {
let contents = read_file_contents().await?;
Ok(())
}#[tokio::main]
async fn main() {
match process_file().await {
Ok(()) => println!("File processed successfully."),
Err(err) => eprintln!("Error processing file: {}", err),
}
}
Funcția read_file_contents returnează un io::Result care reprezintă posibilitatea unei erori I/O. Prin utilizarea ? operator după fiecare operațiune asincronă, Tokio runtime va propaga erorile în stiva de apeluri.
Funcția principală gestionează rezultatul cu o declarație de potrivire care tipărește un text bazat pe rezultatul operației.
Reqwest folosește programarea asincronă pentru operațiuni HTTP
Multe lăzi populare, inclusiv Reqwest, folosesc Tokio pentru a furniza operațiuni HTTP asincrone.
Puteți folosi Tokio cu Reqwest pentru a face mai multe solicitări HTTP fără a bloca alte sarcini. Tokio vă poate ajuta să gestionați mii de conexiuni simultane și să gestionați eficient resursele.