溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
本篇內容主要講解“rust異步代碼async/.await的內部運行機制是什么”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“rust異步代碼async/.await的內部運行機制是什么”吧!
首先讓我們先創建一個Cargo項目：
~$ cargo new --bin sleepus-interruptus
如果你期望和教程使用的編譯器保持一致，可以添加一個內容為1.39.0的rust-toolchain文件。
在繼續下面的內容之前，先運行cargo run確保環境沒有問題。
我們要寫一個簡單的程序，它可以顯示10次Sleepus消息，每次間隔0.5秒；同時顯示5次Interruptus消息，每次間隔1秒。下面是相當簡單的rust實現代碼：
use std::thread::{sleep};
use std::time::Duration;
fn sleepus() {
for i in 1..=10 {
println!("Sleepus {}", i);
sleep(Duration::from_millis(500));
}
}
fn interruptus() {
for i in 1..=5 {
println!("Interruptus {}", i);
sleep(Duration::from_millis(1000));
}
}
fn main() {
sleepus();
interruptus();
}不過，上面的代碼會同步執行兩個操作，它會先顯示完所有的Sleepus消息，然后再顯示Interruptus消息。而我們期望的是這兩種消息交織顯示，也就是說Interruptus消息可以打斷Sleepus消息的顯示。
有兩個辦法可以實現交織顯示的目標。顯而易見的一個是為每個函數創建一個單獨的線程，然后等待線程執行完畢。
use std::thread::{sleep, spawn};
fn main() {
let sleepus = spawn(sleepus);
let interruptus = spawn(interruptus);
sleepus.join().unwrap();
interruptus.join().unwrap();
}需要指出的是：
我們使用spawn(sleepus)而不是spawn(sleepus())來創建線程。后者將 立即執行sleepus()然后將其執行結果傳給spawn，這不是我們期望的- 我在主函數種使用join()來等待子線程結束，并使用unwrap()來處理 可以發生的故障，因為我懶。
另一種實現方法是創建一個輔助線程，然后在主線程種調用其中一個函數：
fn main() {
let sleepus = spawn(sleepus);
interruptus();
sleepus.join().unwrap();
}這種方法效率更高，因為只需要額外創建一個線程，并且也沒有什么副作用，因此我推薦使用這個方法。
不過這兩種方法都不是異步解決方案！我們使用兩個由操作系統管理的線程來并發執行兩個同步任務！接下來讓我們嘗試如何在單一線程內讓兩個任務協作執行！
我們將從較高層次的抽象開始，然后逐步深入rust異步編程的細節。現在讓我們以async風格重寫前面的應用。
首先在Cargo.toml中添加以下依賴：
async-std = { version = "1.2.0", features = ["attributes"] }現在我們可以將應用重寫為：
use async_std::task::{sleep, spawn};
use std::time::Duration;
async fn sleepus() {
for i in 1..=10 {
println!("Sleepus {}", i);
sleep(Duration::from_millis(500)).await;
}
}
async fn interruptus() {
for i in 1..=5 {
println!("Interruptus {}", i);
sleep(Duration::from_millis(1000)).await;
}
}
#[async_std::main]
async fn main() {
let sleepus = spawn(sleepus());
interruptus().await;
sleepus.await;
}主要的修改說明如下：
我們不再使用std::thread中的sleep和spawn函數，而是采用async_std::task。- 在sleepus和interruptus函數前都加async
在調用sleep之后，我們補充了.await。注意不是.await()調用，而是一個新語法
在主函數上使用#[async_std::main]屬性
主函數前也有async關鍵字
我們現在使用spawn(sleepus())而不是spawn(sleepus)，這表示直接調用sleepus 并將結果傳給spawn
對interruptus()的調用增加.await
對sleepus不再使用join()，而是改用.await語法
看起來有很多修改，不過實際上，我們的代碼結構和之前的版本基本是一致的。現在程序運行和我們的期望一致：采用單一線程進行無阻塞調用。
接下來讓我們分析上述修改到底意味著什么。
在函數定義前添加async主要做了以下3個事：
這將允許你在函數體內使用.await語法。我們接下來會深入探討這一點
它修改了函數的返回類型。async fn foo() -> Bar 實際上返回的是 impl std::future::Future<Output=Bar>
它自動將結果值封裝進一個新的Future對象。我們下面會詳細展示這一點
現在讓我們展開說明第2點。在Rust的標準庫中有一個名為Future的trait，Future有一個關聯類型Output。這個trait的意思是：我承諾當我完成任務時，會給你一個類型為Output的值。例如你可以想象一個異步HTTP客戶端可能會這樣實現：
impl HttpRequest {
fn perform(self) -> impl Future<Output=HttpResponse> { ... }
}在發送HTTP請求時需要一些無阻塞的I/O，我們并不希望阻塞調用線程，但是需要最終得到響應結果。
async fn sleepus()的結果類型隱含為()。因此我們的Future的Output也應該為()。這意味著我們需要修改函數為：
fn sleepus() -> impl std::future::Future<Output=()>
不過如果只修改這里，編譯就會出現如下錯誤：
error[E0728]: `await` is only allowed inside `async` functions and blocks
--> src/main.rs:7:9
|
4 | fn sleepus() -> impl std::future::Future<Output=()> {
| ------- this is not `async`
...
7 | sleep(Duration::from_millis(500)).await;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ only allowed inside `async` functions and blocks
error[E0277]: the trait bound `(): std::future::Future` is not satisfied
--> src/main.rs:4:17
|
4 | fn sleepus() -> impl std::future::Future<Output=()> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::future::Future` is not implemented for `()`
|
= note: the return type of a function must have a statically known size第一個錯誤信息很直接：你只能在async函數或代碼塊中使用.await語法。我們還沒有接觸到異步代碼塊，不過看起來就是這樣：
async {
// async noises intensify
}第二個錯誤消息就是第一個的結果：async關鍵字要求函數返回類型是impl Future。如果沒有這個關鍵字，我們的loop結果類型是()，這顯然不滿足要求。
將整個函數體用一個異步代碼塊包裹起來就解決問題了：
fn sleepus() -> impl std::future::Future<Output=()> {
async {
for i in 1..=10 {
println!("Sleepus {}", i);
sleep(Duration::from_millis(500)).await;
}
}
}可能我們并不需要所有這些async/.await。如果我們移除sleepus的.await會怎么樣？令人吃驚的是，居然編譯通過了，雖然給出了一個警告：
warning: unused implementer of `std::future::Future` that must be used --> src/main.rs:8:13 | 8 | sleep(Duration::from_millis(500)); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: `#[warn(unused_must_use)]` on by default = note: futures do nothing unless you `.await` or poll them
我們在生成一個Future值但沒有使用它。如果查看程序的輸出，你可以理解編譯器的警告是什么意思了：
Interruptus 1 Sleepus 1 Sleepus 2 Sleepus 3 Sleepus 4 Sleepus 5 Sleepus 6 Sleepus 7 Sleepus 8 Sleepus 9 Sleepus 10 Interruptus 2 Interruptus 3 Interruptus 4 Interruptus 5
我們所有的Sleepus消息輸出都沒有延遲。問題在于對sleep的調用實際上沒有讓當前線程休息，它只是生成一個實現了Future的值，然后當承諾最終實現時，我們知道的確發生了延遲。但是由于我們簡單地忽略了Future，因此實際上沒有利用延遲。
為了理解.await語法到底做了什么，我們接下來直接使用Future值來實現我們的函數。首先從不用async塊開始。
如果我們丟掉async代碼塊，看起來就是這樣：
fn sleepus() -> impl std::future::Future<Output=()> {
for i in 1..=10 {
println!("Sleepus {}", i);
sleep(Duration::from_millis(500));
}
}這樣編譯會出現以下錯誤：
error[E0277]: the trait bound `(): std::future::Future` is not satisfied
--> src/main.rs:4:17
|
4 | fn sleepus() -> impl std::future::Future<Output=()> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::future::Future` is not implemented for `()`
|上面錯誤是由于for循環的結果類型為()，它沒有實現Future這個trait。修復這個問題的一種辦法是在for循環后面加一句話使其返回Future的實現類型。我們已經知道可以用這個：sleep：
fn sleepus() -> impl std::future::Future<Output=()> {
for i in 1..=10 {
println!("Sleepus {}", i);
sleep(Duration::from_millis(500));
}
sleep(Duration::from_millis(0))
}現在我們依然會看到在for循環內存在未使用的Future值的警告信息，不過返回值那個錯誤已經解決掉了。這個sleep調用實際上什么也沒做，我們可以將其替換為一個真正的占位Future：
fn sleepus() -> impl std::future::Future<Output=()> {
for i in 1..=10 {
println!("Sleepus {}", i);
sleep(Duration::from_millis(500));
}
async_std::future::ready(())
}為了打破沙鍋問到底，讓我們再深入一步，不適用async_std庫中的ready函數，而是定義自己的實現Future的結構。讓我們稱之為DoNothing。
use std::future::Future;
struct DoNothing;
fn sleepus() -> impl Future<Output=()> {
for i in 1..=10 {
println!("Sleepus {}", i);
sleep(Duration::from_millis(500));
}
DoNothing
}問題在于DoNothing還沒有提供Future實現。我們接下來將進行一些編譯器驅動的開發，讓rustc告訴我們如何修復這個程序。第一個錯誤信息是：
the trait bound `DoNothing: std::future::Future` is not satisfied
因此讓我們補上這個trait的實現：
impl Future for DoNothing {
}繼續報錯：
error[E0046]: not all trait items implemented, missing: `Output`, `poll`
--> src/main.rs:7:1
|
7 | impl Future for DoNothing {
| ^^^^^^^^^^^^^^^^^^^^^^^^^ missing `Output`, `poll` in implementation
|
= note: `Output` from trait: `type Output;`
= note: `poll` from trait: `fn(std::pin::Pin<&mut Self>, &mut std::task::Context<'_>) -> std::task::Poll<<Self as std::future::Future>::Output>`我們還不是真正了解Pin<&mut Self>或者Context，不過我們知道Output。因為我們之前返回()，現在讓我們照做。
use std::pin::Pin;
use std::task::{Context, Poll};
impl Future for DoNothing {
type Output = ();
fn poll(self: Pin<&mut Self>, ctx: &mut Context) -> Poll<Self::Output> {
unimplemented!()
}
}喔！編譯通過了！當然在運行時它會失敗，因為我們的unimplemented!()調用：
thread 'async-std/executor' panicked at 'not yet implemented', src/main.rs:13:9
現在讓我們嘗試實現poll。我們需要返回一個值其類型為Poll<Self::Output>或者 Poll<()>。讓我們看一下Poll的定義：
pub enum Poll<T> {
Ready(T),
Pending,
}利用一些基本的推理，我們可以理解Ready表示“我們的Future已經完成，這是輸出”，而Pending表示“還沒完事兒”。假設我們的DoNothing希望立即返回()類型的輸出，可以這樣：
fn poll(self: Pin<&mut Self>, _ctx: &mut Context) -> Poll<Self::Output> {
Poll::Ready(())
}恭喜！你剛剛實現了自己的第一個Future結構！
還記得我們說過async對函數做的第三件事嗎：自動將結果值封裝為一個新的Future。我們接下來展示這一點。
首先簡化sleepus的定義：
fn sleepus() -> impl Future<Output=()> {
DoNothing
}編譯和運行正常。現在切換回async風格：
async fn sleepus() {
DoNothing
}這時候會報錯：
error[E0271]: type mismatch resolving `<impl std::future::Future as std::future::Future>::Output == ()`
--> src/main.rs:17:20
|
17 | async fn sleepus() {
| ^ expected struct `DoNothing`, found ()
|
= note: expected type `DoNothing`
found type `()`可以看到，當你有了一個async函數或代碼塊，結果會自動封裝到一個Future實現對象里。因此我們需要返回一個impl Future<Output=DoNothing>。現在我們的類型需要是Output=()。
處理很簡單，只需要在DoNothing后面簡單添加.await：
async fn sleepus() {
DoNothing.await
}這讓我們對.await的作用增加了一點直覺：它從DoNothing中提取Output值。不過，我們依然并不真正了解它是如何實現的。
到此，相信大家對“rust異步代碼async/.await的內部運行機制是什么”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
