[Rust] tokio: tokio-console

tokio-console은 tokio 전용 디버깅 도구 환경이다.
복잡한 동시성 환경에서의 리소스 추적, 디버깅 등을 용이하게 해준다.

console CLI 설치

먼저 cargo install을 통해 도구를 설치한다.

cargo install --locked tokio-console

그리고 실행해보면

tokio-console

별 의미있는건 안뜰 것이다.
이건 기본적으로 client 도구고, grpc를 통해 트레이싱을 켜준 앱 서버와 통신하며 기록을 보여준다.

이제 앱을 구성해보자.

앱 구성

tokio 앱이니까 tokio는 당연히 있어야하고, console-subscriber 종속성이 추가로 필요하다.

tokio의 실험적 기능인 tracing도 필요하다. 넣어준다.

예제코드다.

use std::{error::Error, thread};

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    console_subscriber::init();

    loop {
        tokio::spawn(async {
            std::thread::sleep(std::time::Duration::from_secs(10));
            println!("done");
        });

        thread::sleep(std::time::Duration::from_secs(1));
    }
}

별건 없다.
루프돌면서 느릿느릿하게 태스크를 하나씩 띄우고, 10초가 지나면 로그찍고 죽는게 다다.
로직과 별개로 console_subscriber::init(); 초기 선언 한번만 해주면 tracing 서버가 뜬다. 저게 중요하다.

그리고 다음과 같이 실행을 해준다.

RUSTFLAGS="--cfg tokio_unstable" cargo run

저렇게 서버가 뜨고 나서

tokio-console을 다시 켜보면

이번에는 연결이 될 것이다.
여기서 모든 태스크의 현황을 실시간으로 볼 수 있다.
실행중인 태스크는 ▶, 일시정지 상태(sleep)는 ⏸. 정지된 태스크는 ⏹ 로 표시된다.

각각의 태스크가 뜬 줄도 뜨고, 이런저런 정보들이 꽤 표시된다.

엔터쳐서 태스크 상세로 들어가면 조금 더 많은 정보를 확인할 수 있다.

다른 예제: long sleep

아래는 비정상적인 정도로 sleep을 걸고 아무것도 하지 않는 태스크를 하나 만든다.

use std::{error::Error, time::Duration};

use tokio::task::yield_now;

async fn long_sleeps(inc: u64) {
    let millis = inc;
    loop {
        std::thread::sleep(Duration::from_millis(millis));

        yield_now().await;
    }
}

async fn sleep_forever(inc: u64) {
    let millis = inc;
    loop {
        std::thread::sleep(Duration::from_millis(millis));
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    console_subscriber::init();

    let long_sleeps = tokio::task::Builder::new()
        .name("long-sleeps")
        .spawn(long_sleeps(5000))
        .unwrap();

    let sleep_forever = tokio::task::Builder::new()
        .name("sleep-forever")
        .spawn(sleep_forever(5000))
        .unwrap();

    match (long_sleeps.await, sleep_forever.await) {
        (Ok(_), Ok(_)) => println!("Success"),
        (_, _) => println!("Error awaiting tasks."),
    }

    tokio::time::sleep(Duration::from_millis(200)).await;

    Ok(())
}

long_sleeps도 무한으로 돌긴 하지만, yield를 통해 양보를 하는 반면 sleep_forever은 대책없이 루프를 돌며 리소스를 점유한다.

그럼 이런식으로 경고가 항상 뜬다.
데드락이 발생해도 이런 느낌으로 뜨더라

다른 예제: mutex deadlock

아래는 Mutex를 통해 데드락을 유발시키는 예제 코드다.
크게 특별한 것은 없다.

use std::sync::{Arc, Mutex};

#[tokio::main(flavor = "multi_thread", worker_threads = 4)]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    console_subscriber::init();

    let a = Arc::new(Mutex::new(0));
    let b = Arc::new(Mutex::new(0));

    {
        let a = a.clone();
        let b = b.clone();
        tokio::task::Builder::default()
            .name("A")
            .spawn(async move {
                let mut a_num = a.lock().unwrap();
                *a_num += 1;

                let delay = std::time::Duration::from_millis(1000);
                std::thread::sleep(delay);
                let mut b_num = b.lock().unwrap();
                *b_num += 1;
            })
            .unwrap();
    }

    {
        let a = a.clone();
        let b = b.clone();
        tokio::task::Builder::default()
            .name("B")
            .spawn(async move {
                let mut b_num = b.lock().unwrap();
                *b_num += 1;

                let delay = std::time::Duration::from_millis(1000);
                let mut a_num = a.lock().unwrap();
                *a_num += 1;
            })
            .unwrap();
    }

    Ok(())
}

서로서로 lock을 걸면서 먹통되는 전형적인 데드락 코드다.

저걸 관측하면

이런 느낌으로 뜬다.