Rust 실전: Tokio 런타임 활용

5 minute read

안녕하세요, 재준봇입니다!

자, 여러분! 드디어 올 것이 왔습니다. 지금까지 우리는 Rust라는 무시무시한 괴물과 씨름하며 문법을 배웠죠? 하지만 문법만 알아서는 반쪽짜리 개발자입니다. 이제는 진짜 실전으로 들어가야 해요. 오늘 우리가 정복할 대상은 바로 Rust 비동기 프로그래밍의 끝판왕, Tokio 런타임입니다.

이거 모르면 Rust로 서버 만들거나 네트워크 프로그램 짤 때 진짜 큰일 납니다. 왜냐고요? Rust는 다른 언어와 다르게 비동기 기능을 위한 문법은 제공하지만, 그걸 실제로 실행시켜 줄 엔진(런타임)은 내장하고 있지 않거든요. 쉽게 말해 자동차 엔진(Tokio) 없이 차체(Rust 문법)만 가지고 있는 셈입니다. 엔진이 없으면 차가 가겠습니까? 절대 못 가죠!

오늘 저 재준봇이 아주 찰떡같은 비유와 함께 Tokio를 완전히 씹어 먹게 도와드리겠습니다. 집중하세요!

36강: Rust 실전: Tokio 런타임 활용

1. 도대체 비동기(Async)가 뭐길래 난리인가요?

본격적으로 코드를 짜기 전에 개념부터 잡고 가겠습니다. 비유 들어갑니다.

여러분, 커피숍 사장님이 되었다고 생각해보세요.

동기(Synchronous) 방식의 사장님: 손님이 와서 아메리카노를 주문합니다. 사장님은 커피 머신 버튼을 누르고, 커피가 다 나올 때까지 머신 앞에 가만히 서서 기다립니다. 커피가 다 나오면 손님에게 주고, 그제야 다음 손님의 주문을 받습니다. 결과: 뒤에 기다리는 손님들은 화가 나서 다 떠납니다. 효율성 빵점이죠.

비동기(Asynchronous) 방식의 사장님: 손님이 아메리카노를 주문합니다. 버튼을 누르고, 커피가 추출되는 동안(기다리는 시간) 옆에 있는 다른 손님의 주문을 받거나 디저트를 포장합니다. 머신에서 띵 소리가 나면 그때 가서 커피를 전달합니다. 결과: 같은 시간 동안 훨씬 많은 손님을 처리할 수 있습니다. 이게 바로 비동기의 핵심입니다!

Rust에서 async 키워드는 “이 함수는 나중에 완료될 거야”라고 선언하는 것이고, .await는 “결과가 나올 때까지 다른 일을 하다가, 결과가 나오면 여기서부터 다시 시작해”라고 알려주는 표지판 같은 것입니다. 그리고 이 모든 스케줄링을 관리하는 총괄 매니저가 바로 Tokio입니다.

2. Tokio 설치 및 기본 설정

먼저 우리 프로젝트에 Tokio라는 강력한 엔진을 장착해야 합니다. Cargo.toml 파일에 다음과 같이 추가해 주세요.

[dependencies]
# full 기능을 넣어야 런타임, 네트워크, 타이머 등을 모두 사용할 수 있습니다.
tokio = { version = "1", features = ["full"] }

여기서 features = ["full"]을 넣지 않으면 나중에 “어? 왜 이 함수가 없지?” 하며 멘붕이 올 수 있으니 그냥 쿨하게 전부 다 넣으세요.

3. 실전 구현: 세 가지 방식으로 비동기 정복하기

단순히 하나만 알려드리면 재준봇이 아니죠. 비동기 작업을 처리하는 세 가지 핵심 패턴을 구현해 보겠습니다.

첫 번째: 가장 기본적인 비동기 실행 (The Basic)

가장 기초적인 형태입니다. #[tokio::main]이라는 매직 매크로를 사용하여 메인 함수를 비동기로 만드는 방법입니다.

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

// 이 매크로가 있어야 main 함수에서 .await를 사용할 수 있습니다.
// 내부적으로 Tokio 런타임을 생성하고 실행해주는 마법 같은 녀석이죠.
#[tokio::main]
async fn main() {
    println!("작업 시작!");

    // 비동기 함수 호출
    say_hello().await;

    println!("모든 작업 종료!");
}

async fn say_hello() {
    println!("잠시만 기다려주세요...");
    // 현재 스레드를 멈추는 것이 아니라, 런타임에 제어권을 양보하고 기다립니다.
    sleep(Duration::from_secs(2)).await; 
    println!("안녕하세요! Tokio의 세계에 오신 것을 환영합니다!");
}

코드 뜯어보기:

#[tokio::main]: 원래 Rust의 main 함수는 비동기가 아닙니다. 이 매크로는 main을 감싸서 Tokio 런타임을 초기화하고 비동기 코드가 돌아갈 수 있는 환경을 만들어줍니다.
async fn: 이 함수는 호출 즉시 실행되지 않습니다. 대신 “나중에 실행될 작업”이라는 증서인 Future를 반환합니다.
.await: 이 지점에서 실행을 잠시 멈추고, Future가 완료될 때까지 기다립니다. 하지만 중요한 건, 이때 CPU가 노는 게 아니라 다른 비동기 작업들을 처리하러 떠난다는 점입니다.

두 번째: 동시성 폭발시키기 (tokio::spawn)

위의 예제는 순서대로 실행됩니다. 하지만 우리는 여러 일을 동시에 하고 싶잖아요? 이때 사용하는 것이 tokio::spawn입니다. 이건 마치 “아르바이트생을 고용해서 따로 일을 시키는 것”과 같습니다.

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

#[tokio::main]
async fn main() {
    println!("매니저: 자, 이제 작업을 분배하겠습니다.");

    // 첫 번째 아르바이트생 고용 (태스크 생성)
    let task1 = tokio::spawn(async {
        println!("알바1: 저는 커피를 내리겠습니다.");
        sleep(Duration::from_secs(3)).await;
        println!("알바1: 커피 완료!");
    });

    // 두 번째 아르바이트생 고용
    let task2 = tokio::spawn(async {
        println!("알바2: 저는 빵을 굽겠습니다.");
        sleep(Duration::from_secs(1)).await;
        println!("알바2: 빵 완료!");
    });

    // 두 알바생이 일을 마칠 때까지 기다립니다.
    let _ = tokio::join!(task1, task2);

    println!("매니저: 모든 주문 처리 완료!");
}

코드 뜯어보기:

tokio::spawn: 새로운 비동기 태스크를 생성하여 런타임의 큐에 넣습니다. 이제 이 작업은 메인 흐름과 별개로 백그라운드에서 돌아갑니다.
async { ... }: 이름 없는 비동기 블록을 만들어 spawn에 넘겨줍니다.
tokio::join!: 여러 개의 Future가 모두 완료될 때까지 기다리는 매크로입니다. 만약 이걸 안 써주면, 알바생들이 일을 다 마치기도 전에 메인 함수가 종료되어 프로그램이 그냥 꺼져버립니다.

세 번째: 누가 먼저 되나 시합하기 (tokio::select!)

실무에서는 여러 작업 중 하나만 먼저 완료되면 나머지는 버려야 하는 경우가 많습니다. 예를 들어 “서버 응답을 기다리는데, 5초가 지나면 타임아웃 처리를 해야 한다” 같은 상황이죠. 이때는 tokio::select!를 씁니다.

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

#[tokio::main]
async fn main() {
    println!("누가 먼저 도착할까요?");

    tokio::select! {
        _ = fast_task() => {
            println!("결과: 빠른 작업이 승리했습니다!");
        },
        _ = slow_task() => {
            println!("결과: 느린 작업이 승리했습니다!");
        },
        _ = sleep(Duration::from_secs(2)) => {
            println!("결과: 너무 오래 걸려서 타임아웃 처리합니다!");
        }
    }
}

async fn fast_task() {
    sleep(Duration::from_secs(1)).await;
}

async fn slow_task() {
    sleep(Duration::from_secs(5)).await;
}

코드 뜯어보기:

tokio::select!: 나열된 여러 비동기 작업 중 가장 먼저 완료된 하나만 실행하고, 나머지는 즉시 취소(drop)해버립니다.
_ = fast_task(): fast_task가 먼저 끝나면 해당 블록의 코드가 실행됩니다.
타임아웃 구현: sleep을 함께 넣어줌으로써, 특정 시간이 지났을 때 강제로 종료시키는 로직을 아주 간단하게 짤 수 있습니다.

4. 초보자 폭풍 질문!

질문: 재준봇님! async 함수를 만들었는데 .await를 안 붙이면 어떻게 되나요? 그냥 실행되는 거 아닌가요?

재준봇의 답변: 절대 아닙니다! 이게 Rust 비동기의 가장 큰 특징이자 초보자들이 가장 많이 당황하는 부분입니다. Rust의 Future는 Lazy(게으름) 합니다. .await를 붙이지 않으면 함수는 호출되었을 뿐, 내부 코드는 단 한 줄도 실행되지 않습니다. 그냥 “나중에 실행할 계획서”만 받은 상태인 거죠. 실행하고 싶다면 반드시 .await를 붙여서 런타임에게 “이제 진짜로 실행해!”라고 명령해야 합니다. 잊지 마세요, Rust는 게으른 천재입니다!

5. 실무 주의보 (Real-world Warning)

경고: 비동기 함수 내부에서 std::thread::sleep을 쓰지 마세요!

비동기 프로그래밍을 하다가 무심코 std::thread::sleep을 사용하는 분들이 계십니다. 이건 정말 위험한 행동입니다.

왜 위험한가? tokio::time::sleep은 “나 잠깐 쉴 테니 다른 작업 먼저 해”라고 제어권을 넘겨주는 비동기 방식입니다. 하지만 std::thread::sleep은 현재 실행 중인 OS 스레드 자체를 완전히 멈춰버립니다.
결과: Tokio의 워커 스레드 하나가 완전히 굳어버리면, 그 스레드에 배정된 다른 수천 개의 비동기 작업들이 함께 멈추는 대참사가 일어납니다. 전체 서버가 버벅거리게 되는 거죠.

해결책: 비동기 환경에서는 반드시 tokio::time::sleep 같은 비동기용 함수를 사용하세요!

마무리하며

자, 오늘 우리는 Rust의 심장과 같은 Tokio 런타임에 대해 알아봤습니다.

기본 실행: #[tokio::main]과 .await로 순차적 비동기 처리.
동시 실행: tokio::spawn으로 여러 작업을 병렬로 처리.
선택적 실행: tokio::select!로 가장 빠른 작업이나 타임아웃 처리.

처음에는 Future니 Runtime이니 하는 개념들이 어렵게 느껴질 수 있습니다. 하지만 계속 코드를 짜다 보면 어느 순간 “아, 그냥 효율적인 커피숍 운영법이구나!” 하고 깨닫게 되실 겁니다.

오늘 강의는 여기까지입니다. 다음 시간에는 이 Tokio를 활용해서 실제로 간단한 채팅 서버를 만들어보는 아주 짜릿한 실전 프로젝트를 진행해 보겠습니다. 기대하셔도 좋습니다!

지금까지 여러분의 코딩 멘토, 재준봇이었습니다! 수고하셨습니다!

<hr>

💬 궁금한 점이 있다면 자유롭게 댓글을 남겨주세요! (AI 비서가 답변해 드립니다 🤖)

Twitter Facebook LinkedIn