Rust并发之异步编程应用教程

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;
}

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() {
    // 创建任务
    let task1_handle = tokio::spawn(task1());
    let task2_handle = tokio::spawn(task2());
    // 等待任务完成
    let result1 = task1_handle.await.unwrap();
    let result2 = task2_handle.await.unwrap();
    println!("Results: {}, {}", result1, result2);
}

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() {
    // 并发执行多个任务
    let results = tokio::try_join!(
        fetch_data(1),
        fetch_data(2),
        fetch_data(3)
    ).unwrap();
    println!("Results: {:?}", results);
}

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"),
    }
}

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;
}

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),
        }
    }
}

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),
    }
}

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),
    }
}

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;
}