Các mô hình lập trình đồng bộ truyền thống thường dẫn đến tắc nghẽn hiệu năng. Điều này là do chương trình chờ các thao tác chậm hoàn tất trước khi tiếp tục tác vụ tiếp theo. Điều này thường dẫn đến việc sử dụng tài nguyên kém và trải nghiệm người dùng chậm.
Lập trình không đồng bộ cho phép bạn viết mã không chặn sử dụng tài nguyên hệ thống một cách hiệu quả. Sử dụng lập trình không đồng bộ, bạn có thể thiết kế các ứng dụng đa nhiệm. Lập trình không đồng bộ rất hữu ích để xử lý một số yêu cầu mạng hoặc xử lý lượng lớn dữ liệu mà không chặn luồng thực thi.
Lập trình không đồng bộ trong Rust
Mô hình lập trình không đồng bộ của Rust cho phép bạn viết mã Rust hiệu quả chạy đồng thời mà không chặn luồng thực thi. Lập trình không đồng bộ có lợi cho các hoạt động I/O, yêu cầu mạng và các tác vụ yêu cầu chờ tài nguyên bên ngoài.
Bạn có thể triển khai phát triển không đồng bộ trong các ứng dụng Rust của mình theo nhiều cách. Chúng bao gồm các tính năng ngôn ngữ, thư viện và thời gian chạy ở Tokyo.
Ngoài ra, mô hình độc quyền của Rust và các nguyên hàm đồng thời như kênh và khóa cho phép phát triển đồng thời an toàn và hiệu quả. Bạn có thể tận dụng các tính năng này bằng lập trình không đồng bộ để tạo ra các hệ thống đồng thời có quy mô tốt và tận dụng được nhiều lõi CPU.
Khái niệm lập trình không đồng bộ trong Rust
Tương lai là nền tảng của lập trình không đồng bộ trong Rust. Tương lai đại diện cho một tính toán không đồng bộ chưa hoàn thành.
Tương lai rất lười biếng (chúng chỉ được thực thi khi bỏ phiếu). Khi bạn gọi phương thức poll() trong tương lai, nó sẽ kiểm tra xem tương lai đã hoàn thành hay cần thực hiện thêm công việc nào khác. Nếu tương lai chưa sẵn sàng, nó trả về Poll::Pending, cho biết rằng tác vụ sẽ được lên lịch để thực hiện sau. Nếu tương lai đã sẵn sàng, nó trả về Poll::Ready với giá trị kết quả.
Bộ công cụ tiêu chuẩn của Rust bao gồm các nguyên hàm I/O không đồng bộ, phiên bản tệp I/O không đồng bộ, hỗ trợ mạng và bộ tính giờ. Những nguyên thủy này cho phép I/O không đồng bộ. Điều này giúp tránh chặn việc thực thi chương trình trong khi chờ tác vụ I/O hoàn thành.
Cú pháp async/await cho phép bạn viết mã không đồng bộ trông giống với mã đồng bộ. Điều này làm cho mã của bạn trực quan và dễ bảo trì.
Cách tiếp cận của Rust đối với lập trình không đồng bộ nhấn mạnh vào tính bảo mật và hiệu suất. Các quy tắc sở hữu và mượn đảm bảo an toàn bộ nhớ và ngăn ngừa các vấn đề tương tranh chung. Cú pháp async/await và tương lai cung cấp một cách trực quan để thể hiện quy trình làm việc không đồng bộ. Bạn có thể sử dụng thời gian chạy của bên thứ ba để quản lý các tác vụ nhằm thực thi hiệu quả.
Bạn có thể kết hợp các tính năng ngôn ngữ, thư viện và thời gian chạy này để viết mã hiệu suất cao. Nó cung cấp một khuôn khổ mạnh mẽ và tiện dụng để xây dựng các hệ thống không đồng bộ. Điều này khiến Rust trở thành lựa chọn phổ biến cho các dự án yêu cầu xử lý hiệu quả các tác vụ I/O và tính đồng thời cao.
Phiên bản rỉ sét 1.39 trở lên không hỗ trợ các hoạt động không đồng bộ trong thư viện Rust tiêu chuẩn. Bạn sẽ cần hộp của bên thứ ba để sử dụng cú pháp async/await nhằm xử lý các hoạt động không đồng bộ trong Rust. Bạn có thể sử dụng các gói của bên thứ ba như Tokyo hoặc async-std để làm việc với cú pháp async/await.
Lập trình không đồng bộ từ Tokyo
Tokyo là thời gian chạy không đồng bộ mạnh mẽ cho Rust. Nó cung cấp chức năng để tạo ra các ứng dụng có hiệu quả cao và có thể mở rộng. Bạn có thể khai thác sức mạnh của lập trình không đồng bộ từ Tokyo. Nó cũng cung cấp các tính năng mở rộng.
Cốt lõi của Tokyo là mô hình thực hiện nhiệm vụ và lập kế hoạch không đồng bộ. Tokyo cho phép bạn viết mã không đồng bộ với cú pháp async/await. Điều này cho phép sử dụng hiệu quả tài nguyên hệ thống và thực hiện đồng thời các tác vụ. Vòng lặp sự kiện Tokyo quản lý hiệu quả việc lập kế hoạch nhiệm vụ. Điều này đảm bảo sử dụng tối ưu lõi CPU và giảm thiểu chi phí chuyển đổi ngữ cảnh.
Máy kết hợp Tokyo giúp bạn dễ dàng điều phối và soạn thảo các nhiệm vụ. Tokyo cung cấp các công cụ mạnh mẽ để phối hợp và phân công nhiệm vụ. Bạn có thể đợi nhiều nhiệm vụ hoàn thành bằng tính năng kết hợp, chọn nhiệm vụ hoàn thành đầu tiên bằng tính năng chọn và chạy đua với nhau bằng tính năng đua.
Thêm trường hợp Tokyo vào phần phụ thuộc của tệp Cargo.toml.
[dependencies]
tokio = { version = "1.9", features = ["full"] }
Đây là cách bạn có thể sử dụng cú pháp async/await trong chương trình Tokyo Rust của mình:
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;
}
Hàm hello_world không đồng bộ, vì vậy nó có thể sử dụng từ khóa chờ đợi để tạm dừng thực thi cho đến khi có giải pháp trong tương lai. Hàm hello_world in “Xin chào” ra bảng điều khiển. Thời lượng cuộc gọi::from_secs(1) tạm dừng thực thi hàm trong một giây. Từ khóa chờ đợi chờ giấc ngủ hoàn thành trong tương lai. Cuối cùng, hàm hello_world in ra “World!” đến bảng điều khiển.
Hàm chính là hàm async với #[tokio::main] thuộc tính. Chỉ định hàm chính làm điểm bắt đầu cho thời gian chạy Tokyo. hello_world().await thực thi hello_world không đồng bộ.
Trì hoãn nhiệm vụ Tokyo
Một nhiệm vụ phổ biến trong lập trình không đồng bộ là sử dụng độ trễ hoặc lên lịch cho các tác vụ chạy trong một khoảng thời gian nhất định. Thời gian chạy tokyo cung cấp cơ chế sử dụng bộ định thời và độ trễ không đồng bộ thông qua mô-đun tokyo::time.
Đây là cách bạn có thể trì hoãn hoạt động với thời gian chạy Tokyo:
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.");
}
Hàm delay_Operation giới thiệu độ trễ hai giây bằng phương thức ngủ. Hàm delay_Operation không đồng bộ, vì vậy nó có thể sử dụng chờ đợi để tạm dừng thực thi cho đến khi độ trễ kết thúc.
Xử lý lỗi trong các chương trình không đồng bộ
Xử lý lỗi trong mã Rust không đồng bộ bao gồm việc sử dụng loại Kết quả và xử lý lỗi Rust với ? nhà điều hành.
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),
}
}
Hàm read_file_contents trả về io::Result thể hiện khả năng xảy ra lỗi I/O. qua ? toán tử sau mỗi thao tác không đồng bộ, thời gian chạy Tokyo sẽ truyền lỗi lên ngăn xếp cuộc gọi.
Hàm chính xử lý kết quả bằng một câu lệnh so khớp in văn bản dựa trên kết quả của thao tác.
Reqwest sử dụng lập trình không đồng bộ cho các hoạt động HTTP
Nhiều hộp thư phổ biến, bao gồm Reqwest, sử dụng Tokyo để cung cấp các hoạt động HTTP không đồng bộ.
Bạn có thể sử dụng Tokyo với Reqwest để thực hiện một số yêu cầu HTTP mà không chặn các tác vụ khác. Tokyo có thể giúp bạn xử lý hàng nghìn kết nối đồng thời và quản lý tài nguyên của bạn một cách hiệu quả.
