async Rust: Tokio и асинхронность

1async fn fetch_data() -> String {
2    "Hello from async".to_string()
3}
4
5#[tokio::main]
6async fn main() {
7    let result = fetch_data().await;
8    println!("{}", result);
9}

1use tokio;
2
3#[tokio::main]
4async fn main() {
5    // Tokio runtime автоматически создаётся
6    println!("Running in Tokio runtime");
7}
8
9// Или с явной конфигурацией
10#[tokio::main(flavor = "multi_thread", worker_threads = 10)]
11async fn main() {
12    // ...
13}

1use tokio::task;
2
3#[tokio::main]
4async fn main() {
5    // Запуск задачи
6    let handle = task::spawn(async {
7        // Асинхронная работа
8        "result from task"
9    });
10
11    // Ожидание результата
12    let result = handle.await.unwrap();
13    println!("{}", result);
14}

1use std::future::Future;
2use std::pin::Pin;
3
4// Future — это значение, которое станет доступным в будущем
5fn my_future() -> impl Future<Output = String> {
6    async {
7        "hello".to_string()
8    }
9}

1use std::future::Future;
2use std::pin::Pin;
3
4fn make_future() -> Pin<Box<dyn Future<Output = i32>>> {
5    Box::pin(async {
6        42
7    })
8}

1async fn get_user(id: u32) -> User {
2    // await приостанавливает выполнения до готовности результата
3    let response = reqwest::get(&format!("https://api.example.com/users/{}", id))
4        .await
5        .unwrap();
6
7    response.json().await.unwrap()
8}

1use tokio::join;
2
3async fn main() {
4    let (user, orders) = join!(
5        get_user(1),
6        get_orders(1)
7    );
8
9    println!("User: {:?}", user);
10    println!("Orders: {:?}", orders);
11}

1use tokio_stream::StreamExt;
2
3async fn main() {
4    let mut stream = tokio_stream::iter(vec![1, 2, 3, 4, 5]);
5
6    while let Some(value) = stream.next().await {
7        println!("Got: {}", value);
8    }
9}

1use tokio_stream::Stream;
2use std::pin::Pin;
3use std::task::{Context, Poll};
4
5fn create_stream() -> impl Stream<Item = i32> {
6    async_stream::stream! {
7        for i in 0..10 {
8            tokio::time::sleep(Duration::from_millis(100)).await;
9            yield i;
10        }
11    }
12}

1use tokio::time::{timeout, Duration};
2
3async fn main() {
4    // Таймаут 5 секунд
5    match timeout(Duration::from_secs(5), long_operation()).await {
6        Ok(result) => println!("Got: {}", result),
7        Err(_) => println!("Operation timed out"),
8    }
9}

1use tokio::sync::mpsc;
2
3#[tokio::main]
4async fn main() {
5    let (tx, mut rx) = mpsc::channel(32);
6
7    let tx2 = tx.clone();
8
9    tokio::spawn(async move {
10        tx.send("hello from task 1").await.unwrap();
11    });
12
13    tokio::spawn(async move {
14        tx2.send("hello from task 2").await.unwrap();
15    });
16
17    while let Some(message) = rx.recv().await {
18        println!("Received: {}", message);
19    }
20}

1use tokio::sync::Mutex;
2use std::sync::Arc;
3
4async fn main() {
5    let data = Arc::new(Mutex::new(0));
6
7    let mut handles = vec![];
8
9    for _ in 0..10 {
10        let data = Arc::clone(&data);
11        let handle = tokio::spawn(async move {
12            let mut num = data.lock().await;
13            *num += 1;
14        });
15        handles.push(handle);
16    }
17
18    for handle in handles {
19        handle.await.unwrap();
20    }
21
22    println!("Result: {}", *data.lock().await);
23}

1use tokio;
2
3#[derive(Debug)]
4enum AppError {
5    NetworkError,
6    ParseError,
7}
8
9async fn fetch_data() -> Result<String, AppError> {
10    let response = reqwest::get("https://api.example.com")
11        .await
12        .map_err(|_| AppError::NetworkError)?;
13
14    let body = response.text().await
15        .map_err(|_| AppError::ParseError)?;
16
17    Ok(body)
18}
19
20#[tokio::main]
21async fn main() {
22    match fetch_data().await {
23        Ok(data) => println!("Data: {}", data),
24        Err(e) => println!("Error: {:?}", e),
25    }
26}

1// Плохо: блокирует runtime
2async fn bad() {
3    std::thread::sleep(Duration::from_secs(1)); // Блокирует весь поток
4}
5
6// Хорошо: использует таймер Tokio
7async fn good() {
8    tokio::time::sleep(Duration::from_secs(1)).await;
9}

1tokio::spawn(async {
2    // Долгая операция, не блокируя основной поток
3    expensive_computation().await;
4});