מבוא לתכנות אסינכרוני בחלודה

מודלים מסורתיים של תכנות סינכרוני מובילים לעתים קרובות לצווארי בקבוק בביצועים. הסיבה לכך היא שהתוכנית ממתינה להשלמת פעולות איטיות לפני שהיא עוברת למשימה הבאה. זה גורם לרוב לשימוש לקוי במשאבים ולחווית משתמש איטית.

תכנות אסינכרוני מאפשר לך לכתוב קוד לא חוסם המנצל את משאבי המערכת בצורה יעילה. על ידי מינוף תכנות אסינכרוני, אתה יכול לעצב אפליקציות שמבצעות משימות מרובות. תכנות אסינכרוני שימושי לטיפול במספר בקשות רשת או לעיבוד כמויות גדולות של נתונים מבלי לחסום את זרימת הביצוע.

תכנות אסינכרוני בחלודה

מודל התכנות האסינכרוני של Rust מאפשר לך כתוב קוד Rust יעיל שפועל במקביל מבלי לחסום את זרימת הביצוע. תכנות אסינכרוני מועיל בעת התמודדות עם פעולות קלט/פלט, בקשות רשת ומשימות הכרוכות בהמתנה למשאבים חיצוניים.

אתה יכול ליישם תכנות אסינכרוני באפליקציות Rust שלך בכמה דרכים. אלה כוללים תכונות שפה, ספריות וזמן ריצה של Tokio.

גַם, מודל הבעלות של Rust ופרימיטיבים של מקביליות כמו ערוצים ומנעולים מאפשרים תכנות בו-זמני בטוח ויעיל. אתה יכול למנף את התכונות האלה עם תכנות אסינכרוני כדי לבנות מערכות במקביל שמתרחבות היטב ומשתמשות בליבות מעבד מרובות.

מושגי התכנות האסינכרוני של Rust

עתידים מספקים בסיס לתכנות אסינכרוני ב- Rust. עתיד מייצג חישוב אסינכרוני שלא בוצע לחלוטין.

חוזים עתידיים הם עצלנים (הם מוצאים להורג רק בעת ההצבעה). כשאתה קורא לעתיד מִשׁאָל() השיטה, היא בודקת אם העתיד הושלם או שהוא זקוק לעבודה נוספת. אם העתיד לא מוכן, הוא חוזר סקר:: בהמתנה, המציין שיש לתזמן את המשימה לביצוע מאוחר יותר. אם העתיד מוכן, הוא חוזר סקר:: מוכן עם הערך המתקבל.

שרשרת הכלים הסטנדרטית של Rust כוללת פרימיטיבים אסינכרוניים של קלט/פלט, גרסה אסינכרית של קלט/פלט קבצים, רשתות וטיימרים. פרימיטיבים אלה מאפשרים לך לבצע פעולות I/O באופן אסינכרוני. זה עוזר להימנע מחסימת ביצוע של תוכנית בזמן ההמתנה להשלמת משימות קלט/פלט.

תחביר ה-async/await מאפשר לך לכתוב קוד אסינכרוני שנראה דומה לקוד סינכרוני. זה הופך את הקוד שלך לאינטואיטיבי וקל לתחזוקה.

הגישה של Rust לתכנות אסינכרוני מדגישה בטיחות וביצועים. כללי הבעלות וההשאלה מבטיחים את בטיחות הזיכרון ומונעים בעיות נפוצות במקביל. תחביר אסינכרון/המתנה וחוזים עתידיים מספקים דרך אינטואיטיבית לבטא זרימות עבודה אסינכרוניות. אתה יכול להשתמש בזמן ריצה של צד שלישי כדי לנהל משימות לביצוע יעיל.

אתה יכול לשלב את תכונות השפה, הספריות וזמן הריצה האלה כדי לכתוב קוד בעל ביצועים גבוהים. הוא מספק מסגרת חזקה וארגונומית לבניית מערכות אסינכרוניות. זה הופך את Rust לבחירה פופולרית עבור פרויקטים הדורשים טיפול יעיל במשימות הקשורות ל-I/O ובמקיפות גבוהה.

Rust גרסה 1.39 ואילך אינן תומכות בפעולות אסינכרוניות בספרייה הסטנדרטית של Rust. תזדקק לארגז של צד שלישי כדי להשתמש ב- אסינכרון/לְהַמתִין תחביר לטיפול בפעולות א-סינכרוניות ב- Rust. אתה יכול להשתמש בחבילות של צד שלישי כמו טוקיו אוֹ async-std לעבוד עם תחביר אסינכרון/ממתין.

תכנות אסינכרוני עם טוקיו

Tokio הוא זמן ריצה אסינכרוני חזק עבור Rust. הוא מספק פונקציונליות לבניית יישומים בעלי ביצועים גבוהים וניתנים להרחבה. אתה יכול לרתום את הכוח של תכנות אסינכרוני עם Tokio. זה גם מספק תכונות להרחבה.

בליבה של Tokio הוא מודל תזמון וביצוע משימות אסינכרוני. Tokio מאפשר לך לכתוב קוד אסינכרוני עם תחביר ה-async/wait. זה מאפשר ניצול יעיל של משאבי המערכת וביצוע משימות במקביל. לולאת האירועים של Tokio מנהלת ביעילות את תזמון המשימות. זה מבטיח ניצול אופטימלי של ליבות המעבד וממזער את התקורה של החלפת הקשר.

הקומבינטורים של טוקיו הופכים את תיאום המשימות וההרכבה לקלים. Tokio מספקת כלי תיאום משימות וקומפוזיציה רבי עוצמה. אתה יכול להמתין עד להשלמת משימות מרובות עם הצטרפות, בחר את המשימה הראשונה שהושלמה עם בחירה ומשימות מרוץ אחת נגד השנייה עם הגזע.

תוסיף את ה טוקיו ארגז שלך Cargo.toml מדור התלות של הקובץ.

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

כך תוכל להשתמש בתחביר אסינכרון/ממתין בתוכניות Rust שלך עם Tokio:

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;
}

ה שלום עולם הפונקציה היא אסינכרונית, כך שהיא יכולה להשתמש ב- לְהַמתִין מילת מפתח כדי להשהות את ביצועה עד לפתרון עתיד. ה שלום עולם הדפסי פונקציות "שלום, " לקונסולה. ה משך:: from_secs (1) קריאת function משעה את ביצוע הפונקציה לשנייה. ה לְהַמתִין מילת מפתח מחכה לעתיד השינה. סוף - סוף, ה שלום עולם הדפסי פונקציות "עוֹלָם!" לקונסולה.

ה רָאשִׁי פונקציה היא פונקציה אסינכרונית עם #[tokio:: main] תְכוּנָה. הוא מייעד את הפונקציה הראשית כנקודת הכניסה לזמן הריצה של Tokio. ה hello_world().await מבצע את הפונקציה hello_world באופן אסינכרוני.

דחיית משימות עם טוקיו

משימה רווחת בתכנות אסינכרוני היא שימוש בעיכובים או תזמון משימות לרוץ בטווח זמן מוגדר. זמן הריצה של tokio מספק מנגנון לשימוש בטיימרים אסינכרוניים ועיכובים דרך טוקיו:: זמן מודול.

כך תוכל לדחות פעולה עם זמן הריצה של Tokio:

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.");
}

ה delayed_operation הפונקציה מציגה השהייה של שתי שניות עם לִישׁוֹן שיטה. ה delayed_operation הפונקציה היא אסינכרונית, כך שהיא יכולה להשתמש בהמתנה כדי להשהות את ביצועה עד להשלמת העיכוב.

טיפול בשגיאות בתוכניות אסינכרוניות

טיפול בשגיאות בקוד Rust אסינכרוני כולל שימוש ב- תוֹצָאָה סוג ו טיפול בשגיאות חלודה עם ה ? מַפעִיל.

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),
 }
}

ה read_file_contents הפונקציה מחזירה את an io:: תוצאה המייצג את האפשרות של שגיאת קלט/פלט. על ידי שימוש ב ? מפעיל לאחר כל פעולה אסינכרונית, זמן הריצה של Tokio יפיץ שגיאות בערימת השיחות.

ה רָאשִׁי הפונקציה מטפלת בתוצאה עם a התאמה הצהרה שמדפיסה טקסט על סמך תוצאת הפעולה.

Reqwest משתמשת בתכנות אסינכרוני עבור פעולות HTTP

ארגזים פופולריים רבים, כולל Reqwest, משתמשים ב-Tokio כדי לספק פעולות HTTP אסינכרוניות.

אתה יכול להשתמש ב-Tokio עם Reqwest כדי לבצע מספר בקשות HTTP מבלי לחסום משימות אחרות. Tokio יכולה לעזור לך לטפל באלפי חיבורים במקביל ולנהל משאבים ביעילות.