TOKIO Archives - icodebroker

[RUST/TOKIO] Duration 구조체 : from_millis 연관 함수를 사용해 밀리초 단위 Duration 객체 구하기

■ Duration 구조체의 from_millis 연관 함수를 사용해 밀리초 단위 Duration 객체를 구하는 방법을 보여준다. ▶ 예제 코드 (RS)


use tokio::time;

let duration : time::Duration = time::Duration::from_millis(1000);

use tokio::time;

let duration : time::Duration = time::Duration::from_millis(1000);

[RUST/TOKIO] join! 매크로 : 비동기 병렬 처리 완료시까지 대기하기

■ join! 매크로를 사용해 비동기 병렬 처리 완료시까지 대기하는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_project"
version = "0.1.0"
edition = "2021"

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

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

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

▶ src/main.rs


use tokio::time;

async fn print_message_async(second_count : u64, message : &str)
{
    time::sleep(time::Duration::from_secs(second_count)).await;

    println!("{} : {}", second_count, message);
}

#[tokio::main]
async fn main()
{
    tokio::spawn(print_message_async(3, "메시지 #1"));
    tokio::spawn(print_message_async(2, "메시지 #2"));
    tokio::spawn(print_message_async(1, "메시지 #3"));

    time::sleep(time::Duration::from_secs(4)).await;

    println!("------------");

    tokio::join!
    (
        print_message_async(2, "메시지 #4"),
        print_message_async(3, "메시지 #5"),
        print_message_async(1, "메시지 #6")
    );
}

use tokio::time;

async fn print_message_async(second_count : u64, message : &str)

{

time::sleep(time::Duration::from_secs(second_count)).await;

println!("{} : {}", second_count, message);

}

#[tokio::main]

async fn main()

{

tokio::spawn(print_message_async(3, "메시지 #1"));

tokio::spawn(print_message_async(2, "메시지 #2"));

tokio::spawn(print_message_async(1, "메시지 #3"));

time::sleep(time::Duration::from_secs(4)).await;

println!("------------");

tokio::join!

(

print_message_async(2, "메시지 #4"),

print_message_async(3, "메시지 #5"),

print_message_async(1, "메시지 #6")

);

}

test_project.zip

[RUST/TOKIO] spawn 함수 : 비동기 병렬 처리하기

■ spawn 함수를 사용해 비동기 병렬 처리하는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_project"
version = "0.1.0"
edition = "2021"

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

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

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

▶ src/main.rs


use tokio::time;

async fn print_message_async(second_count : u64, message : &str)
{
    time::sleep(time::Duration::from_secs(second_count)).await;

    println!("{} : {}", second_count, message);
}

#[tokio::main]
async fn main()
{
    tokio::spawn(print_message_async(3, "메시지 #1"));
    tokio::spawn(print_message_async(2, "메시지 #2"));
    tokio::spawn(print_message_async(1, "메시지 #3"));

    time::sleep(time::Duration::from_secs(4)).await;
}

use tokio::time;

async fn print_message_async(second_count : u64, message : &str)

{

time::sleep(time::Duration::from_secs(second_count)).await;

println!("{} : {}", second_count, message);

}

#[tokio::main]

async fn main()

{

tokio::spawn(print_message_async(3, "메시지 #1"));

tokio::spawn(print_message_async(2, "메시지 #2"));

tokio::spawn(print_message_async(1, "메시지 #3"));

time::sleep(time::Duration::from_secs(4)).await;

}

test_project.zip

[RUST/TOKIO] 블럭문을 사용해 비동기 처리하기

■ 블럭문을 사용해 비동기 처리를 하는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_project"
version = "0.1.0"
edition = "2021"

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

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

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

▶ src/main.rs


use tokio::time;

#[tokio::main]
async fn main()
{
    for i in 1..=3
    {
        println!("#{} START TO GET MESSAGE", i);

        let message = async
        {
            time::sleep(time::Duration::from_secs(1)).await;

            return String::from(format!("MESSAGE {}", i));
        }.await;

        println!("{}", message);
    }
}

use tokio::time;

#[tokio::main]

async fn main()

{

for i in 1..=3

{

println!("#{} START TO GET MESSAGE", i);

let message = async

{

time::sleep(time::Duration::from_secs(1)).await;

return String::from(format!("MESSAGE {}", i));

}.await;

println!("{}", message);

}

test_project.zip

[RUST/TOKIO] tokio 크레이트를 사용해 반환값을 갖는 비동기 처리하기

■ tokio 크레이트를 사용해 반환값을 갖는 비동기 처리를 하는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_project"
version = "0.1.0"
edition = "2021"

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

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

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

▶ src/main.rs


use tokio::time;

#[tokio::main]
async fn main()
{
    for i in 1..=3
    {
        println!("#{} START TO GET MESSAGE", i);

        let message : String = get_message_async(i).await;

        println!("{}", message);
    }
}

async fn get_message_async(value : i32) -> String
{
    time::sleep(time::Duration::from_secs(1)).await;

    return String::from(format!("MESSAGE {}", value));
}

use tokio::time;

#[tokio::main]

async fn main()

{

for i in 1..=3

{

println!("#{} START TO GET MESSAGE", i);

let message : String = get_message_async(i).await;

println!("{}", message);

}

async fn get_message_async(value : i32) -> String

{

time::sleep(time::Duration::from_secs(1)).await;

return String::from(format!("MESSAGE {}", value));

}

test_project.zip

[RUST/TOKIO] sleep 함수 : 실행을 일정 시간 대기하기

■ sleep 함수를 사용해 실행을 일정 시간 동안 대기하는 방법을 보여준다. ▶ 예제 코드 (RS)


use tokio::time;

let duration : time::Duration = time::Duration::from_secs(1);

time::sleep(duration).await;

use tokio::time;

let duration : time::Duration = time::Duration::from_secs(1);

time::sleep(duration).await;

[RUST/TOKIO] Duration 구조체 : from_secs 연관 함수를 사용해 초단위 Duration 객체 구하기

■ Duration 구조체의 from_secs 연관 함수를 사용해 초단위 Duration 객체를 구하는 방법을 보여준다. ▶ 예제 코드 (RS)


use tokio::time;

let duration : time::Duration = time::Duration::from_secs(1);

use tokio::time;

let duration : time::Duration = time::Duration::from_secs(1);

[RUST/TOKIO] tokio 크레이트를 사용해 비동기 처리하기

■ tokio 크레이트를 사용해 비동기 처리를 하는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_project"
version = "0.1.0"
edition = "2021"

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

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

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

▶ src/main.rs


#[tokio::main]
async fn main()
{
    let future  = print_message_async("메시지 #1");

    println!("메시지 #2");

    future.await;
}

async fn print_message_async(message : &'static str)
{
    println!("{}", message);
}

#[tokio::main]

async fn main()

{

let future = print_message_async("메시지 #1");

println!("메시지 #2");

future.await;

}

async fn print_message_async(message : &'static str)

{

println!("{}", message);

}

test_project.zip