Rust 异步编程实战：构建高效的并发应用

最新推荐文章于 2026-06-28 21:35:05 发布

原创最新推荐文章于 2026-06-28 21:35:05 发布 · 82 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#rust #github #python

Rust 异步编程实战：构建高效的并发应用

异步编程的重要性

在现代软件开发中，异步编程变得越来越重要。它允许程序在等待IO操作（如网络请求、文件读写）时继续执行其他任务，从而提高程序的响应速度和吞吐量。Rust作为一种系统编程语言，也提供了强大的异步编程支持，通过tokio等库实现高效的异步IO操作。本文将介绍Rust异步编程的核心概念、常用库和最佳实践。

基本概念

异步 vs 同步

同步：代码按顺序执行，一个操作完成后才开始下一个操作
异步：代码可以在等待某个操作完成时执行其他任务，提高程序的并发度

Future

在Rust中，异步操作由Future trait表示，它代表一个可能尚未完成的计算。

pub trait Future {
    type Output;
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
}

async/await

Rust 1.39+ 引入了async和await关键字，使得异步代码的编写更加简洁和直观。

常用库

tokio

Tokio是Rust最流行的异步运行时，它提供了事件循环、任务调度、网络IO等功能。

# Cargo.toml
[dependencies]
tokio = { version = "1.0", features = ["full"] }

async-std

async-std是另一个流行的异步运行时，它提供了与标准库类似的API。

# Cargo.toml
[dependencies]
async-std = { version = "1.0", features = ["full"] }

基本用法

简单的异步函数

use tokio::time::{sleep, Duration};

async fn say_hello() {
    println!("Hello");
    sleep(Duration::from_secs(1)).await;
    println!("World");
}

#[tokio::main]
async fn main() {
    say_hello().await;
}

并行执行任务

use tokio::time::{sleep, Duration};

async fn task1() {
    println!("Task 1 started");
    sleep(Duration::from_secs(2)).await;
    println!("Task 1 completed");
}

async fn task2() {
    println!("Task 2 started");
    sleep(Duration::from_secs(1)).await;
    println!("Task 2 completed");
}

#[tokio::main]
async fn main() {
    // 并行执行两个任务
    let task1_handle = tokio::spawn(task1());
    let task2_handle = tokio::spawn(task2());
    
    // 等待两个任务完成
    task1_handle.await.unwrap();
    task2_handle.await.unwrap();
    
    println!("All tasks completed");
}

异步IO操作

use tokio::fs::File;
use tokio::io::{self, AsyncReadExt, AsyncWriteExt};

async fn read_file() -> io::Result<()> {
    let mut file = File::open("example.txt").await?;
    let mut buffer = Vec::new();
    file.read_to_end(&mut buffer).await?;
    println!("File content: {}", String::from_utf8_lossy(&buffer));
    Ok(())
}

async fn write_file() -> io::Result<()> {
    let mut file = File::create("output.txt").await?;
    file.write_all(b"Hello, Rust async IO!").await?;
    Ok(())
}

#[tokio::main]
async fn main() {
    if let Err(e) = read_file().await {
        eprintln!("Error reading file: {}", e);
    }
    
    if let Err(e) = write_file().await {
        eprintln!("Error writing file: {}", e);
    }
}

网络编程

use tokio::net::{TcpListener, TcpStream};
use tokio::io::{self, AsyncReadExt, AsyncWriteExt};

async fn handle_client(mut socket: TcpStream) {
    let mut buffer = [0; 1024];
    
    loop {
        let n = socket.read(&mut buffer).await
            .expect("Failed to read from socket");
        
        if n == 0 {
            break;
        }
        
        socket.write_all(&buffer[0..n]).await
            .expect("Failed to write to socket");
    }
}

#[tokio::main]
async fn main() {
    let listener = TcpListener::bind("127.0.0.1:8080").await
        .expect("Failed to bind");
    
    println!("Server listening on 127.0.0.1:8080");
    
    loop {
        let (socket, _) = listener.accept().await
            .expect("Failed to accept connection");
        
        tokio::spawn(handle_client(socket));
    }
}

高级特性

Stream

Stream是异步版本的迭代器，它允许异步地产生多个值。

use tokio::stream::{self, StreamExt};

#[tokio::main]
async fn main() {
    let mut stream = stream::iter(vec![1, 2, 3, 4, 5]);
    
    while let Some(item) = stream.next().await {
        println!("Item: {}", item);
    }
}

异步通道

异步通道用于在不同任务之间传递消息。

use tokio::sync::mpsc;

#[tokio::main]
async fn main() {
    // 创建通道，容量为3
    let (tx, mut rx) = mpsc::channel(3);
    
    // 发送任务
    tokio::spawn(async move {
        for i in 1..=5 {
            tx.send(i).await.unwrap();
            println!("Sent: {}", i);
        }
    });
    
    // 接收任务
    while let Some(msg) = rx.recv().await {
        println!("Received: {}", msg);
    }
}

互斥锁

异步互斥锁用于在异步代码中保护共享资源。

use tokio::sync::Mutex;
use std::sync::Arc;

#[tokio::main]
async fn main() {
    let counter = Arc::new(Mutex::new(0));
    
    let mut handles = vec![];
    
    for i in 0..10 {
        let counter = Arc::clone(&counter);
        
        let handle = tokio::spawn(async move {
            let mut lock = counter.lock().await;
            *lock += 1;
            println!("Task {}: counter = {}", i, *lock);
        });
        
        handles.push(handle);
    }
    
    for handle in handles {
        handle.await.unwrap();
    }
    
    let lock = counter.lock().await;
    println!("Final counter: {}", *lock);
}

实用应用

异步HTTP服务器

use tokio::net::{TcpListener, TcpStream};
use tokio::io::{self, AsyncReadExt, AsyncWriteExt};

async fn handle_request(mut socket: TcpStream) {
    let mut buffer = [0; 1024];
    
    // 读取请求
    let n = socket.read(&mut buffer).await
        .expect("Failed to read from socket");
    
    let request = String::from_utf8_lossy(&buffer[0..n]);
    println!("Received request:\n{}", request);
    
    // 构建响应
    let response = "HTTP/1.1 200 OK\r\n"
        + "Content-Type: text/plain\r\n"
        + "Content-Length: 12\r\n"
        + "\r\n"
        + "Hello, World!";
    
    // 发送响应
    socket.write_all(response.as_bytes()).await
        .expect("Failed to write to socket");
}

#[tokio::main]
async fn main() {
    let listener = TcpListener::bind("127.0.0.1:8080").await
        .expect("Failed to bind");
    
    println!("HTTP server listening on 127.0.0.1:8080");
    
    loop {
        let (socket, addr) = listener.accept().await
            .expect("Failed to accept connection");
        
        println!("Accepted connection from {}", addr);
        
        tokio::spawn(handle_request(socket));
    }
}

异步数据库操作

use tokio_postgres::{NoTls, Error};

#[tokio::main]
async fn main() -> Result<(), Error> {
    // 连接到数据库
    let (client, connection) = tokio_postgres::connect(
        "host=localhost user=postgres password=postgres dbname=test",
        NoTls,
    ).await?;
    
    // 后台运行连接
    tokio::spawn(async move {
        if let Err(e) = connection.await {
            eprintln!("Connection error: {}", e);
        }
    });
    
    // 创建表
    client.execute(
        "CREATE TABLE IF NOT EXISTS users (id SERIAL PRIMARY KEY, name TEXT NOT NULL)",
        &[],
    ).await?;
    
    // 插入数据
    client.execute(
        "INSERT INTO users (name) VALUES ($1)",
        &[&"Alice"],
    ).await?;
    
    // 查询数据
    let rows = client.query(
        "SELECT id, name FROM users",
        &[],
    ).await?;
    
    for row in rows {
        let id: i32 = row.get(0);
        let name: &str = row.get(1);
        println!("User: {} - {}", id, name);
    }
    
    Ok(())
}

异步爬虫

use tokio::net::TcpStream;
use tokio::io::{self, AsyncReadExt, AsyncWriteExt};
use std::str;

async fn fetch_url(host: &str, path: &str) -> io::Result<String> {
    // 连接到服务器
    let mut socket = TcpStream::connect((host, 80)).await?;
    
    // 发送HTTP请求
    let request = format!("GET {} HTTP/1.1\r\nHost: {}\r\nConnection: close\r\n\r\n", path, host);
    socket.write_all(request.as_bytes()).await?;
    
    // 读取响应
    let mut buffer = Vec::new();
    socket.read_to_end(&mut buffer).await?;
    
    Ok(String::from_utf8_lossy(&buffer).to_string())
}

#[tokio::main]
async fn main() {
    match fetch_url("example.com", "/").await {
        Ok(response) => println!("Response:\n{}", response),
        Err(e) => eprintln!("Error: {}", e),
    }
}