Rust并發(fā)之異步編程應(yīng)用教程

更新時(shí)間：2026年05月05日 11:23:21 作者：第一程序員

這篇文章主要介紹了Rust并發(fā)之異步編程應(yīng)用教程,Rust的異步編程是一種強(qiáng)大的并發(fā)編程范式,它允許我們編寫高效、響應(yīng)迅速的應(yīng)用程序,通過掌握異步編程的高級(jí)應(yīng)用,我們可以充分利用系統(tǒng)資源,提高應(yīng)用程序的性能,需要的朋友可以參考下

1. 異步編程基礎(chǔ)

Rust 的異步編程是通過 async/await 語法和 Future trait 實(shí)現(xiàn)的。

use tokio::time::{sleep, Duration};
async fn hello() {
    println!("Hello");
    sleep(Duration::from_secs(1)).await;
    println!("World");
}
#[tokio::main]
async fn main() {
    hello().await;
}

2. 高級(jí)異步技巧

2.1 任務(wù)管理

use tokio::time::{sleep, Duration};
async fn task1() -> String {
    sleep(Duration::from_secs(1)).await;
    println!("Task 1 completed");
    "Task 1 result".to_string()
}
async fn task2() -> String {
    sleep(Duration::from_secs(2)).await;
    println!("Task 2 completed");
    "Task 2 result".to_string()
}
#[tokio::main]
async fn main() {
    // 創(chuàng)建任務(wù)
    let task1_handle = tokio::spawn(task1());
    let task2_handle = tokio::spawn(task2());
    // 等待任務(wù)完成
    let result1 = task1_handle.await.unwrap();
    let result2 = task2_handle.await.unwrap();
    println!("Results: {}, {}", result1, result2);
}

2.2 并發(fā)執(zhí)行

use tokio::time::{sleep, Duration};
async fn fetch_data(id: u32) -> String {
    sleep(Duration::from_secs(1)).await;
    format!("Data {}", id)
}
#[tokio::main]
async fn main() {
    // 并發(fā)執(zhí)行多個(gè)任務(wù)
    let results = tokio::try_join!(
        fetch_data(1),
        fetch_data(2),
        fetch_data(3)
    ).unwrap();
    println!("Results: {:?}", results);
}

2.3 超時(shí)處理

use tokio::time::{sleep, Duration, timeout};
async fn slow_operation() -> String {
    sleep(Duration::from_secs(2)).await;
    "Operation completed".to_string()
}
#[tokio::main]
async fn main() {
    match timeout(Duration::from_secs(1), slow_operation()).await {
        Ok(result) => println!("Result: {}", result),
        Err(_) => println!("Operation timed out"),
    }
}

2.4 異步流

use tokio::stream::StreamExt;
async fn generate_numbers() {
    let mut stream = tokio::stream::iter(1..=5);
    while let Some(number) = stream.next().await {
        println!("Number: {}", number);
    }
}
#[tokio::main]
async fn main() {
    generate_numbers().await;
}

3. 實(shí)際應(yīng)用場景

3.1 網(wǎng)絡(luò)請求

use reqwest::Client;
async fn fetch_url(url: &str) -> Result<String, reqwest::Error> {
    let client = Client::new();
    let response = client.get(url).send().await?;
    response.text().await
}
#[tokio::main]
async fn main() {
    let urls = [
        "https://api.github.com",
        "https://api.example.com",
        "https://api.google.com"
    ];
    let mut tasks = Vec::new();
    for url in &urls {
        tasks.push(tokio::spawn(fetch_url(url)));
    }
    for (url, task) in urls.iter().zip(tasks) {
        match task.await.unwrap() {
            Ok(content) => println!("URL: {}, Length: {}", url, content.len()),
            Err(e) => println!("URL: {}, Error: {:?}", url, e),
        }
    }
}

3.2 文件 I/O

use tokio::fs::File;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
async fn read_file(filename: &str) -> Result<String, std::io::Error> {
    let mut file = File::open(filename).await?;
    let mut content = String::new();
    file.read_to_string(&mut content).await?;
    Ok(content)
}
async fn write_file(filename: &str, content: &str) -> Result<(), std::io::Error> {
    let mut file = File::create(filename).await?;
    file.write_all(content.as_bytes()).await?;
    Ok(())
}
#[tokio::main]
async fn main() {
    match read_file("input.txt").await {
        Ok(content) => {
            println!("Read content: {}", content);
            if let Err(e) = write_file("output.txt", &content.to_uppercase()).await {
                println!("Error writing file: {:?}", e);
            } else {
                println!("File written");
            }
        }
        Err(e) => println!("Error reading file: {:?}", e),
    }
}

3.3 數(shù)據(jù)庫操作

use sqlx::postgres::PgPool;
async fn get_users(pool: &PgPool) -> Result<Vec<(i32, String)>, sqlx::Error> {
    sqlx::query_as::<_, (i32, String)>("SELECT id, name FROM users")
        .fetch_all(pool)
        .await
}
#[tokio::main]
async fn main() {
    let pool = PgPool::connect("postgres://postgres:password@localhost/test").await.unwrap();
    match get_users(&pool).await {
        Ok(users) => {
            for (id, name) in users {
                println!("User: {} - {}", id, name);
            }
        }
        Err(e) => println!("Error fetching users: {:?}", e),
    }
}

3.4 Web 服務(wù)器

use warp::Filter;
async fn hello(name: String) -> Result<impl warp::Reply, std::convert::Infallible> {
    Ok(format!("Hello, {}!", name))
}
#[tokio::main]
async fn main() {
    let hello_route = warp::path!(String)
        .and_then(hello);
    let root_route = warp::path!("")
        .map(|| "Hello, World!");
    let routes = hello_route.or(root_route);
    println!("Server started on http://localhost:3030");
    warp::serve(routes)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

4. 最佳實(shí)踐

使用 async 和 await：使用 async 定義異步函數(shù)，使用 await 等待異步操作完成。
使用 tokio::spawn：使用 tokio::spawn 創(chuàng)建任務(wù)，實(shí)現(xiàn)并發(fā)執(zhí)行。
使用 try_join!：使用 try_join! 宏并發(fā)執(zhí)行多個(gè)任務(wù)，收集結(jié)果。
使用 timeout：使用 timeout 函數(shù)設(shè)置超時(shí)，避免任務(wù)無限等待。
使用異步 I/O：使用 tokio::fs、tokio::net 等異步 I/O 模塊，避免阻塞。
合理使用 BoxFuture：對于復(fù)雜的異步操作，使用 BoxFuture 進(jìn)行類型擦除。
處理錯(cuò)誤：使用 Result 類型和 ? 操作符處理異步錯(cuò)誤。