Rust 비동기 프로그래밍 | async/await, Tokio

· 32분 읽기 · 수정 고급 튜토리얼
Rust 비동기 프로그래밍 | async/await, Tokio

이 글의 핵심

Rust 비동기 프로그래밍에 대한 실전 가이드입니다. async/await, Tokio 등을 예제와 함께 설명합니다.

들어가며

async/await는 Future를 조합해 I/O 대기를 스레드 한 개로 효율적으로 처리하는 쪽에 가깝습니다. 실행기(Tokio 등)가 준비된 작업만 깨우므로, 블로킹 호출과 섞이지 않게 구성하는 것이 중요합니다.

Node.js 이벤트 루프·JavaScript Promise와 같이 “한 스레드에서 많은 I/O를 겹친다”는 인상은 비슷하지만, Tokio는 워커 스레드 풀을 쓰는 경우가 많습니다. Kotlin 코루틴의 suspend와도 자주 비교되고, 스레드에 바로 태우는 C++ std::async와는 역할이 다릅니다.

1. async/await 기초

기본 사용

async fn fetch_data() -> String {
    String::from("데이터")
}

#[tokio::main]
async fn main() {
    let data = fetch_data().await;
    println!("{}", data);
}

여러 비동기 함수

async fn fetch_user(id: u32) -> String {
    format!("사용자 {}", id)
}

async fn fetch_posts(user_id: u32) -> Vec<String> {
    vec![format!("포스트 1"), format!("포스트 2")]
}

#[tokio::main]
async fn main() {
    let user = fetch_user(1).await;
    println!("{}", user);
    
    let posts = fetch_posts(1).await;
    println!("{:?}", posts);
}

2. Tokio 런타임

프로젝트 설정

[dependencies]
tokio = { version = "1", features = ["full"] }

태스크 생성

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

#[tokio::main]
async fn main() {
    let task1 = tokio::spawn(async {
        sleep(Duration::from_secs(1)).await;
        println!("Task 1 완료");
        1
    });
    
    let task2 = tokio::spawn(async {
        sleep(Duration::from_secs(2)).await;
        println!("Task 2 완료");
        2
    });
    
    let (result1, result2) = tokio::join!(task1, task2);
    println!("결과: {:?}, {:?}", result1, result2);
}

병렬 실행

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

async fn task(id: u32, duration: u64) -> u32 {
    sleep(Duration::from_secs(duration)).await;
    println!("Task {} 완료", id);
    id
}

#[tokio::main]
async fn main() {
    let (r1, r2, r3) = tokio::join!(
        task(1, 1),
        task(2, 2),
        task(3, 1),
    );
    
    println!("결과: {}, {}, {}", r1, r2, r3);
}

3. 비동기 I/O

파일 읽기

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

#[tokio::main]
async fn main() -> std::io::Result<()> {
    let mut file = File::open("test.txt").await?;
    let mut contents = String::new();
    file.read_to_string(&mut contents).await?;
    
    println!("{}", contents);
    Ok(())
}

HTTP 요청

use tokio::net::TcpStream;

#[tokio::main]
async fn main() -> std::io::Result<()> {
    let stream = TcpStream::connect("127.0.0.1:8080").await?;
    println!("연결됨");
    Ok(())
}

4. 실전 예제

예제: 병렬 HTTP 요청

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

async fn fetch_url(url: &str) -> Result<String, String> {
    sleep(Duration::from_secs(1)).await;
    Ok(format!("{}의 데이터", url))
}

#[tokio::main]
async fn main() {
    let urls = vec![
        "https://api.example.com/users",
        "https://api.example.com/posts",
        "https://api.example.com/comments",
    ];
    
    let mut tasks = vec![];
    
    for url in urls {
        let task = tokio::spawn(async move {
            fetch_url(url).await
        });
        tasks.push(task);
    }
    
    for task in tasks {
        match task.await {
            Ok(Ok(data)) => println!("받음: {}", data),
            Ok(Err(e)) => println!("에러: {}", e),
            Err(e) => println!("태스크 에러: {}", e),
        }
    }
}

실전 심화 보강

실전 예제: 타임아웃·재시도가 있는 HTTP GET (reqwest)

Cargo.toml:

[dependencies]
tokio = { version = "1", features = ["macros", "rt-multi-thread", "time"] }
reqwest = { version = "0.12", features = ["json", "rustls-tls"] }
serde = { version = "1", features = ["derive"] }
anyhow = "1"
use reqwest::StatusCode;
use serde::Deserialize;
use std::time::Duration;
use tokio::time::sleep;

#[derive(Debug, Deserialize)]
struct Repo {
    name: String,
    stargazers_count: u64,
}

async fn fetch_with_retry(url: &str, max: u32) -> reqwest::Result<Repo> {
    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(5))
        .build()?;

    for attempt in 0..max {
        let resp = client.get(url).send().await?;
        let status = resp.status();
        if status == StatusCode::OK {
            return resp.json::<Repo>().await;
        }
        if status.is_server_error() && attempt + 1 < max {
            sleep(Duration::from_millis(200 * (attempt as u64 + 1))).await;
            continue;
        }
        return Err(resp.error_for_status().unwrap_err());
    }
    unreachable!()
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let url = "https://api.github.com/repos/rust-lang/rust";
    let repo = fetch_with_retry(url, 3).await?;
    println!("{} ★ {}", repo.name, repo.stargazers_count);
    Ok(())
}

자주 하는 실수

  • **async fn 안에서 std::thread::sleep**을 써서 런타임 워커를 막는 경우.
  • spawn한 JoinHandle을 await하지 않고 태스크가 드랍되며 취소되는 줄 아는 경우(스레드 풀과 다름).
  • Mutex를 await 사이에 들고 있는 데드락·지연을 유발하는 경우.

주의사항

  • 블로킹 I/O(일부 파일 API, DNS)는 spawn_blocking으로 격리하는 편이 안전합니다.
  • Tokio 런타임 스레드 수와 CPU 바운드 작업 분리는 rayon 등과 역할을 나눕니다.

실무에서는 이렇게

  • **tokio::select!**로 취소·타임아웃을 한 곳에서 표현합니다.
  • 연결 풀·타임아웃은 reqwest::Client 빌더에서 앱 전역으로 재사용합니다.
  • 로그는 **tracing**으로 스팬을 남겨 비동기 호출 경로를 추적합니다.

비교 및 대안

런타임/스타일특징
Tokio생태계 최대, 네트워크·서버와 궁합
async-stdAPI가 표준 라이브러리 느낌
스레드 + 채널CPU 바운드·간단 파이프라인에 여전히 유효

추가 리소스

비동기 심화: 동작 원리, Future, 런타임 비교, 에러·동시성

async/await 동작 원리

  • async fn은 즉시 완료되지 않는 연산을 나타내는 타입(구현체는 컴파일러가 생성한 상태 머신)을 반환합니다.
  • .await는 “이 Future가 완료될 때까지 실행기(executor)에게 양보한다”는 의미입니다. 스레드가 막히는 것이 아니라, 다른 태스크로 CPU를 넘깁니다.
  • 런타임(Tokio 등)은 **poll**을 반복해 Pending이면 나중에 깨우고, Ready면 다음 단계로 진행합니다.

요약하면: async/await는 문법 설탕이고, 실제로는 Future + 실행기 + I/O 드라이버의 조합입니다.

Future 트레이트

std::future::Future는 “나중에 값이 나올 수 있는 것”을 모델합니다.

use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};

// Future는 poll로 진행 상황을 묻는다 (실제 코드는 보통 async로 작성)
// type Output = T;  // 완료 시 타입
// fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
  • Poll::Pending: 아직 준비 안 됨 → 런타임이 waker로 다시 스케줄링.
  • Poll::Ready(val): 완료.

async 블록은 이 poll 상태 머신으로 변환되므로, .await 지점이 자연스러운 양보 지점이 됩니다.

Tokio vs async-std

항목Tokioasync-std
생태계사실상 표준에 가깝게 넓음 (hyper, tonic, axum 등)경량·std 스타일 API 지향
API 스타일tokio::fs, tokio::net 등 자체 모듈async_std::가 std와 비슷한 이름 공간
선택 가이드새 프로젝트·서버·네트워크는 Tokio가 의존성 정합성이 좋음기존 코드·특정 크레이트가 async-std를 요구할 때

둘 다 비동기 실행 모델은 비슷하지만, 라이브러리 호환을 위해 한쪽으로 통일하는 것이 일반적입니다.

실전 에러 처리

비동기에서도 Result는 그대로입니다. 다만 ?가 여러 .await를 거치므로 에러 타입을 앱 전역으로 통일하면 편합니다.

async fn load() -> anyhow::Result<String> {
    let s = tokio::fs::read_to_string("config.toml").await?;
    Ok(s)
}
  • anyhow::Result: 애플리케이션 코드에서 빠르게 에러를 전파할 때.
  • thiserror: 라이브러리에서 도메인 에러 타입을 정의할 때 (#[derive(Error)]).

JoinHandle은 task.await 시 **Result<T, JoinError>**를 돌려주므로, 스폰 실패·패닉과 본문 Result를 이중으로 매칭하는 패턴이 흔합니다.

match handle.await {
    Ok(Ok(value)) => { /* 성공 */ }
    Ok(Err(e)) => { /* async 블록 내부 Err */ }
    Err(join_err) => { /* 태스크 자체 실패 */ }
}

동시성 제어: Mutex, RwLock, 채널 (Tokio)

비동기 컨텍스트에서는 가능하면 tokio::sync를 사용합니다. std::sync::Mutex를 잡은 채 .await를 호출하면 같은 런타임 워커가 막혀 데드락·처리량 저하가 날 수 있습니다.

use tokio::sync::{Mutex, RwLock, mpsc};

// 공유 상태
let counter = std::sync::Arc::new(Mutex::new(0u64));

let c = counter.clone();
tokio::spawn(async move {
    let mut g = c.lock().await;
    *g += 1;
});

// 읽기 많은 경우 RwLock
let cache = std::sync::Arc::new(RwLock::new(Vec::<String>::new()));

// 태스크 간 메시지 전달
let (tx, mut rx) = mpsc::channel(32);
tokio::spawn(async move {
    while let Some(msg) = rx.recv().await {
        println!("{msg}");
    }
});
tx.send("hello".into()).await.unwrap();
  • Mutex::lock().await: 비동기 친화적 락.
  • RwLock: 읽기/쓰기 비율에 따라 선택.
  • mpsc::channel: 생산자–소비자, 백프레셔(버퍼 크기) 조절.

std::sync의 뮤텍스는 blocking 구간이 짧고 await가 없을 때만 고려합니다.

정리

핵심 요약

  1. async/await: 비동기 함수 정의 및 대기
  2. Future: 비동기 작업 표현
  3. Tokio: 비동기 런타임
  4. tokio::spawn: 비동기 태스크 생성
  5. tokio::join!: 병렬 실행 및 결과 대기
  6. 동작 원리: 상태 머신 + poll / waker, 실행기가 스케줄링
  7. Tokio vs async-std: 생태계·호환성은 보통 Tokio 우선
  8. 에러: anyhow/thiserror, JoinHandle과 내부 Result 구분
  9. 동시성: tokio::sync::{Mutex, RwLock, mpsc}로 await와 함께 사용

다음 단계

  • Rust 웹 개발
  • Rust 테스팅
  • Rust CLI 도구

관련 글

  • C++ 코루틴
  • C++ future와 promise
  • JavaScript 비동기 프로그래밍 | Promise, async/await 완벽 정리
  • Node.js 비동기 프로그래밍 | Callback, Promise, Async/Await
  • Swift 비동기 프로그래밍 | async/await, Task