Hướng dẫn về tính đồng thời không sợ hãi của Rust
Đồng thời là khả năng một chương trình thực thi đồng thời nhiều tác vụ trên cùng một lõi CPU. Các tác vụ đồng thời chạy và hoàn thành trong thời gian chồng chéo mà không có thứ tự cụ thể, không giống như xử lý song song, trong đó nhiều tác vụ hoặc tác vụ phụ của cùng một tác vụ chạy cùng lúc trên phần cứng có nhiều bộ xử lý.
Rust nổi bật với các tính năng hiệu suất và hỗ trợ đồng thời một cách an toàn, hiệu quả. Cách tiếp cận đồng thời của Rust dựa trên khái niệm “đồng thời không sợ hãi” trong đó ngôn ngữ nhằm mục đích giúp dễ dàng viết mã đồng thời an toàn thông qua quyền sở hữu và hệ thống vay vốn thực thi các quy tắc nghiêm ngặt tại thời điểm biên dịch để ngăn chặn dấu vết dữ liệu và đảm bảo an toàn cho bộ nhớ.
Mục Lục
Hiểu đồng thời trong Rust
Rust cung cấp một số nguyên hàm đồng thời để viết các chương trình đồng thời, bao gồm luồng, chuyển thông báo, mutexes, kiểu nguyên tử và async/await cho lập trình không đồng bộ.
Dưới đây là tổng quan về các nguyên hàm đồng thời của Rust:
- chủ đề: Rust cung cấp một std::chủ đề module trong thư viện chuẩn của nó để tạo và quản lý luồng. Bạn có thể sinh ra chủ đề mới với chủ đề::sinh sản chức năng. Các chủ đề::sinh sản có một bao đóng chứa mã để thực thi. Bạn cũng có thể chạy các luồng có thể chạy song song và Rust cung cấp các nguyên hàm đồng bộ hóa để phối hợp thực hiện chúng. Trình kiểm tra mượn đảm bảo rằng các tài liệu tham khảo không dẫn đến các hành vi không mong muốn.
- Thông qua: Mô hình đồng thời của Rust hỗ trợ truyền thông báo giữa các luồng. Bạn sẽ sử dụng các kênh được triển khai thông qua std::sync::mpsc mô-đun để truyền tin nhắn. Một kênh bao gồm một máy phát (Người gửi) và một máy thu (Người nhận). Chủ đề có thể gửi tin nhắn qua máy phát và nhận chúng qua máy thu. Điều này cung cấp một cách giao tiếp an toàn và đồng bộ giữa các luồng.
- Mutexes và các loại nguyên tử: Rust cung cấp nguyên mẫu đồng bộ hóa, bao gồm cả mutexes (std::sync::Mutex) và các loại nguyên tử (std::sync::atomic), để đảm bảo quyền truy cập chia sẻ dữ liệu độc quyền. Mutexes cho phép nhiều luồng truy cập dữ liệu đồng thời trong khi ngăn chặn các cuộc đua dữ liệu. Các loại nguyên tử cung cấp các hoạt động nguyên tử trên dữ liệu được chia sẻ, chẳng hạn như tăng bộ đếm mà không yêu cầu khóa rõ ràng.
- Không đồng bộ/Đang chờ và Tương lai: Rỉ sét không đồng bộ/chờ đợi cú pháp cung cấp chức năng viết mã không đồng bộ mà bạn có thể thực thi đồng thời. Các chương trình không đồng bộ xử lý hiệu quả các tác vụ liên kết với I/O cho phép các chương trình thực hiện các tác vụ khác trong khi chờ đợi các thao tác I/O khác. rỉ sét không đồng bộ/chờ đợi cú pháp dựa trên hợp đồng tương lai và bạn có thể cung cấp năng lượng cho chúng bằng async-std hoặc tokio thư viện thời gian chạy.
Các luồng rỉ sét rất nhẹ và không có chi phí thời gian chạy khiến chúng rất phù hợp cho các ứng dụng hiệu suất cao. Nguyên mẫu đồng thời của Rust tích hợp liền mạch với nhiều thư viện và khung cho các nhu cầu đồng thời khác nhau.
Cách sử dụng chủ đề sinh sản trong Rust
Bạn sẽ sử dụng std::chủ đề mô-đun để sinh ra chủ đề. Các std::thread::spawn chức năng cho phép bạn tạo một luồng mới sẽ chạy đồng thời với luồng chính hoặc bất kỳ luồng hiện có nào khác trong chương trình của bạn.
Đây là cách bạn có thể sinh ra một chủ đề với std::thread::spawn chức năng:
use std::thread;fn main() {
let thread_handle = thread::spawn(|| {
println!("Hello from the new thread!");
});
thread_handle.join().unwrap();
println!("Hello from the main thread!");
}
Các chủ yếu chức năng tạo một chủ đề mới với chủ đề::sinh sản chức năng bằng cách chuyển vào một bao đóng chứa mã để thực thi trong luồng (trong trường hợp này, bao đóng là một hàm ẩn danh). Việc đóng in một thông báo cho biết rằng luồng mới đang chạy.
Các tham gia phương pháp trên thread_handle cho phép luồng chính đợi luồng được sinh ra hoàn tất thực thi. Bằng cách gọi tham giachức năng đảm bảo rằng luồng chính đợi luồng được sinh ra hoàn tất trước khi tiếp tục.
Bạn có thể sinh ra nhiều luồng và sử dụng một vòng lặp hoặc bất kỳ cấu trúc điều khiển Rust nào khác để tạo nhiều bao đóng và sinh ra các luồng cho mỗi luồng.
use std::thread;fn main() {
let num_threads = 5;
let mut thread_handles = vec![];
for i in 0..num_threads {
let thread_handle = thread::spawn(move || {
println!("Hello from thread {}", i);
});
thread_handles.push(thread_handle);
}
for handle in thread_handles {
handle.join().unwrap();
}
println!("All threads finished!");
}
Vòng lặp for sinh ra năm luồng, mỗi luồng được gán cho một mã định danh duy nhất Tôi với biến vòng lặp. Các đóng cửa nắm bắt giá trị của Tôi với di chuyển từ khóa để tránh các vấn đề về quyền sở hữu và thread_handles vector lưu trữ các chủ đề cho sau này trong tham gia vòng.
Sau khi sinh ra tất cả các chủ đề, các chủ yếu chức năng lặp đi lặp lại trên thread_handles véc tơ, cuộc gọi tham gia trên mỗi tay cầm và đợi tất cả các luồng thực thi.
Truyền tin nhắn qua các kênh
Bạn có thể chuyển tin nhắn qua chuỗi với các kênh. Rust cung cấp chức năng truyền tin nhắn trong std::sync::mpsc mô-đun. Đây, mpsc là viết tắt của “nhiều nhà sản xuất, một người tiêu dùng” và nó cho phép giao tiếp giữa nhiều luồng bằng cách gửi và nhận tin nhắn qua các kênh.
Đây là cách bạn triển khai thông báo truyền qua các kênh liên lạc giữa các luồng trong chương trình của mình:
use std::sync::mpsc;
use std::thread;fn main() {
let (sender, receiver) = mpsc::channel();
thread::spawn(move || {
sender.send("Hello from the thread!").unwrap();
});
let received_message = receiver.recv().unwrap();
println!("Received message: {}", received_message);
}
Các chủ yếu chức năng tạo một kênh với mpsc::channel() trả về một người gửi và một người nhận. Các người gửi gửi tin nhắn đến người nhận mà nhận được tin nhắn. Các chủ yếu chức năng tiến hành sinh ra chủ đề và di chuyển quyền sở hữu của Người gửi đến việc đóng cửa chủ đề. Bên trong đóng cửa chủ đề, các người gửi.send() chức năng gửi tin nhắn qua kênh.
Các máy thu.recv() chức năng nhận tin nhắn bằng cách tạm dừng thực thi cho đến khi luồng nhận được tin nhắn. Các chủ yếu chức năng in tin nhắn ra bàn điều khiển sau khi nhận tin nhắn thành công.
Lưu ý rằng việc gửi tin nhắn qua kênh sẽ tiêu tốn người gửi. Nếu bạn cần gửi tin nhắn từ nhiều luồng, bạn có thể sao chép người gửi bằng người gửi.clone() chức năng.
Ngoài ra, các mpsc mô-đun cung cấp các phương thức khác như try_recv()mà tính năng không chặn cố gắng nhận tin nhắn và lần lặp()tạo một trình vòng lặp trên các tin nhắn đã nhận.
Tin nhắn truyền qua các kênh cung cấp một cách an toàn và thuận tiện để giao tiếp giữa các luồng trong khi tránh các cuộc đua dữ liệu và đảm bảo đồng bộ hóa phù hợp.
Mô hình cho vay và sở hữu của Rust đảm bảo an toàn cho bộ nhớ
Rust kết hợp quyền sở hữu, mượn và trình kiểm tra mượn để cung cấp một khung lập trình mạnh mẽ, an toàn, đồng thời.
Trình kiểm tra mượn hoạt động như một mạng lưới an toàn, phát hiện các sự cố tiềm ẩn tại thời điểm biên dịch thay vì dựa vào kiểm tra thời gian chạy hoặc thu gom rác.