مقدمه ای بر برنامه نویسی ناهمزمان در Rust

برنامه نویسی ناهمزمان مفهوم مهمی است که به عنوان یک توسعه دهنده Rust باید از آن آگاه باشید.

مدل‌های برنامه‌نویسی همزمان سنتی اغلب منجر به گلوگاه‌های عملکردی می‌شوند. این به این دلیل است که برنامه قبل از رفتن به کار بعدی منتظر می ماند تا عملیات کند کامل شود. این اغلب منجر به استفاده ضعیف از منابع و تجربه کاربری کند می شود.

برنامه نویسی ناهمزمان به شما امکان می دهد کدهای غیر مسدود کننده ای بنویسید که از منابع سیستم به طور موثر استفاده می کند. با استفاده از برنامه نویسی ناهمزمان، می توانید برنامه هایی را طراحی کنید که چندین کار را انجام می دهند. برنامه نویسی ناهمزمان برای رسیدگی به چندین درخواست شبکه یا پردازش مقادیر زیادی داده بدون مسدود کردن جریان اجرا مفید است.

برنامه نویسی ناهمزمان در Rust

مدل برنامه‌نویسی ناهمزمان Rust به شما امکان می‌دهد کد Rust کارآمدی را بنویسید که به طور همزمان بدون مسدود کردن جریان اجرا اجرا می‌شود. برنامه نویسی ناهمزمان هنگام برخورد با عملیات ورودی/خروجی، درخواست های شبکه و وظایفی که شامل انتظار برای منابع خارجی است، سودمند است.

شما می توانید برنامه نویسی ناهمزمان را در برنامه های Rust خود به روش های مختلفی پیاده سازی کنید. اینها شامل ویژگی های زبان، کتابخانه ها و زمان اجرا توکیو می شود.

همچنین، مدل مالکیت Rust و اصول اولیه همزمانی مانند کانال ها و قفل ها، برنامه نویسی همزمان ایمن و کارآمد را امکان پذیر می کند. شما می توانید از این ویژگی ها با برنامه نویسی ناهمزمان برای ساختن سیستم های همزمان که به خوبی مقیاس می شوند و از چندین هسته CPU استفاده می کنند، استفاده کنید.

مفاهیم برنامه نویسی ناهمزمان Rust

آتی پایه ای برای برنامه نویسی ناهمزمان در Rust فراهم می کند. آینده بیانگر یک محاسبات ناهمزمان است که به طور کامل اجرا نشده است.

آینده ها تنبل هستند (آنها فقط در زمان نظرسنجی اعدام می شوند). وقتی یک متد () poll را فراخوانی می‌کنید، بررسی می‌کند که آیا آینده تکمیل شده است یا به کار اضافی نیاز دارد. اگر آینده آماده نباشد، Poll::Pending را برمی گرداند، که نشان می دهد وظیفه باید برای اجرای بعدی برنامه ریزی شود. اگر آینده آماده باشد، Poll::Ready را با مقدار حاصل برمی گرداند.

زنجیره ابزار استاندارد Rust شامل ورودی/خروجی های ابتدایی ناهمزمان، نسخه ناهمگام فایل ورودی/خروجی، شبکه و تایمر است. این اولیه به شما اجازه می دهد تا عملیات I/O را به صورت ناهمزمان انجام دهید. این به جلوگیری از مسدود شدن اجرای برنامه در زمان انتظار برای تکمیل وظایف I/O کمک می کند.

سینتکس async/wait به شما امکان می دهد کد ناهمزمان بنویسید که شبیه به کد همزمان است. این باعث می شود کد شما بصری باشد و نگهداری آن آسان باشد.

رویکرد Rust به برنامه نویسی ناهمزمان بر ایمنی و عملکرد تأکید دارد. قوانین مالکیت و قرض گرفتن ایمنی حافظه را تضمین می کند و از مشکلات همزمانی رایج جلوگیری می کند. سینتکس Async/wait و قراردادهای آتی روشی بصری برای بیان گردش‌های کاری ناهمزمان ارائه می‌کنند. می توانید از زمان اجرا شخص ثالث برای مدیریت وظایف برای اجرای کارآمد استفاده کنید.

می‌توانید این ویژگی‌های زبان، کتابخانه‌ها و زمان اجرا را برای نوشتن کدهایی با کارایی بالا ترکیب کنید. این یک چارچوب قدرتمند و ارگونومیک برای ساخت سیستم های ناهمزمان ارائه می دهد. این امر Rust را به گزینه ای محبوب برای پروژه هایی تبدیل می کند که نیاز به مدیریت کارآمد وظایف I/O-bound و همزمانی بالا دارند.

Rust نسخه 1.39 و نسخه های بعدی از عملیات ناهمزمان در کتابخانه استاندارد Rust پشتیبانی نمی کند. برای استفاده از syntax async/wait برای مدیریت عملیات ناهمزمان در Rust به یک جعبه شخص ثالث نیاز دارید. برای کار با syntax async/await می‌توانید از بسته‌های شخص ثالث مانند Tokio یا async-std استفاده کنید.

برنامه نویسی ناهمزمان با توکیو

Tokio یک زمان اجرا ناهمزمان قوی برای Rust است. این قابلیت برای ساخت برنامه های کاربردی با کارایی بالا و مقیاس پذیر فراهم می کند. می توانید با توکیو از قدرت برنامه نویسی ناهمزمان استفاده کنید. همچنین ویژگی هایی را برای توسعه پذیری ارائه می دهد.

هسته اصلی توکیو برنامه ریزی و مدل اجرای وظایف ناهمزمان آن است. توکیو به شما امکان می دهد کدهای ناهمزمان را با نحو async/wait بنویسید. این امکان استفاده کارآمد از منابع سیستم و اجرای همزمان وظایف را فراهم می کند. حلقه رویداد توکیو به طور موثر برنامه ریزی کارها را مدیریت می کند. این امر استفاده بهینه از هسته های CPU را تضمین می کند و سربار تعویض متن را به حداقل می رساند.

ترکیب‌کننده‌های توکیو هماهنگی و ترکیب وظایف را آسان می‌کنند. توکیو ابزارهای قدرتمندی برای هماهنگی و ترکیب وظایف ارائه می دهد. می توانید منتظر بمانید تا چندین کار با Join کامل شوند، اولین کار تکمیل شده را با انتخاب انتخاب کنید و با مسابقه با یکدیگر مسابقه دهید.

جعبه توکیو را به بخش وابستگی های فایل Cargo.toml خود اضافه کنید.

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

در اینجا نحوه استفاده از syntax async/wait در برنامه های Rust با توکیو آورده شده است:

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

تابع hello_world ناهمزمان است، بنابراین می‌تواند از کلمه کلیدی await برای توقف اجرای خود استفاده کند تا زمانی که آینده حل شود. تابع hello_world “Hello” را در کنسول چاپ می کند. فراخوانی تابع Duration::from_secs(1) اجرای تابع را برای یک ثانیه به حالت تعلیق در می آورد. کلمه کلیدی await منتظر می ماند تا آینده خواب کامل شود. در نهایت، تابع hello_world “World!” به کنسول

تابع اصلی یک تابع ناهمزمان با ویژگی #[tokio::main] است. تابع اصلی را به عنوان نقطه ورودی برای زمان اجرا توکیو تعیین می کند. hello_world().await تابع hello_world را به صورت ناهمزمان اجرا می کند.

به تعویق انداختن وظایف با توکیو

یک کار رایج در برنامه نویسی ناهمزمان، استفاده از تاخیر یا زمان بندی وظایف برای اجرا در یک محدوده زمانی مشخص است. زمان اجرا tokio مکانیزمی را برای استفاده از تایمرهای ناهمزمان و تأخیر از طریق ماژول tokio::time فراهم می کند.

در اینجا نحوه به تاخیر انداختن عملیات با زمان اجرا توکیو آمده است:

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

تابع delayed_operation یک تاخیر دو ثانیه ای را با روش خواب معرفی می کند. تابع delayed_operation ناهمزمان است، بنابراین می تواند از await برای توقف اجرای آن تا زمانی که تاخیر کامل شود استفاده کند.

مدیریت خطا در برنامه های ناهمزمان

مدیریت خطا در کد Rust ناهمزمان شامل استفاده از نوع Result و مدیریت خطاهای Rust با ? اپراتور.

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?;
    // Process the file contents
    Ok(())
}

#[tokio::main]
async fn main() {
    match process_file().await {
        Ok(()) => println!("File processed successfully."),
        Err(err) => eprintln!("Error processing file: {}", err),
    }
}

تابع read_file_contents یک io:: نتیجه را برمی‌گرداند که احتمال خطای I/O را نشان می‌دهد. با استفاده از ? اپراتور پس از هر عملیات ناهمزمان، زمان اجرا Tokio خطاها را در پشته تماس منتشر می کند.

تابع اصلی نتیجه را با یک دستور مطابقت کنترل می کند که متنی را بر اساس نتیجه عملیات چاپ می کند.

Reqwest از برنامه نویسی ناهمزمان برای عملیات HTTP استفاده می کند

بسیاری از جعبه‌های محبوب، از جمله Reqwest، از توکیو برای ارائه عملیات HTTP ناهمزمان استفاده می‌کنند.

می توانید از Tokio با Reqwest برای ایجاد چندین درخواست HTTP بدون مسدود کردن سایر وظایف استفاده کنید. توکیو می تواند به شما در مدیریت هزاران اتصال همزمان و مدیریت موثر منابع کمک کند.

منبع مقاله