RUST Archives - 12 중 2 번째 페이지

[RUST/COMMON] struct 키워드 : 튜플 구조체 만들기

■ struct 키워드를 사용해 튜플 구조체를 만드는 방법을 보여준다. ▶ 예제 코드 (RS)


fn main()
{
    struct Color(i32, i32, i32);
    struct Point(i32, i32, i32);

    let black  : Color = Color(30, 20, 10);
    let origin : Point = Point(10, 20, 30);

    println!("{}, {}, {}", black.0 , black.1 , black.2 );
    println!("{}, {}, {}", origin.0, origin.1, origin.2);
}

/*
30, 20, 10
10, 20, 30
*/

fn main()

{

struct Color(i32, i32, i32);

struct Point(i32, i32, i32);

let black : Color = Color(30, 20, 10);

let origin : Point = Point(10, 20, 30);

println!("{}, {}, {}", black.0 , black.1 , black.2 );

println!("{}, {}, {}", origin.0, origin.1, origin.2);

}

30, 20, 10

10, 20, 30

[RUST/COMMON] Iterator 트레잇 : rev 메소드를 사용해 반복자 방향 반대로 하기

■ Iterator 트레잇의 rev 메소드를 사용해 반복자 방향을 반대로 하는 방법을 보여준다. ▶ 예제 코드 (RS)


for index in (1..11).rev()
{
    println!("{}", index);
}

for index in (1..11).rev()

{

println!("{}", index);

}

[RUST/RAND] ThreadRng 구조체 : gen_range 메소드를 사용해 숫자 맞추기 게임 만들기

■ ThreadRng 구조체의 gen_range 메소드를 사용해 임의의 난수를 생성하고 숫자를 맞추는 게임을 만드는 방법을 보여준다. ▶ Cargo.toml


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

[dependencies]
rand = "0.8.0"

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

rand = "0.8.0"

▶ src/main.rs


use std::cmp;
use std::io;

use rand;
use rand::rngs;
use rand::Rng;

fn main()
{
    println!("Guess the number!");

    let mut thread_rng: rngs::ThreadRng = rand::thread_rng();

    let secret_number : u32 = thread_rng.gen_range(1..=100);

    loop
    {
        println!("Please input your guess.");

        let mut guess_string : String = String::new();

        io::stdin().read_line(&mut guess_string).expect("Failed to read line");

        let guess_number : u32 = match guess_string.trim().parse()
        {
            Ok(number) => number,
            Err(_)          => continue
        };

        println!("You guessed : {}", guess_number);

        match guess_number.cmp(&secret_number)
        {
            cmp::Ordering::Less    => println!("Too small!"),
            cmp::Ordering::Greater => println!("Too big!"),
            cmp::Ordering::Equal   =>
            {
                println!("You win!");

                break;
            }
        }
    }
}

use std::cmp;

use std::io;

use rand;

use rand::rngs;

use rand::Rng;

fn main()

{

println!("Guess the number!");

let mut thread_rng: rngs::ThreadRng = rand::thread_rng();

let secret_number : u32 = thread_rng.gen_range(1..=100);

loop

{

println!("Please input your guess.");

let mut guess_string : String = String::new();

io::stdin().read_line(&mut guess_string).expect("Failed to read line");

let guess_number : u32 = match guess_string.trim().parse()

{

Ok(number) => number,

Err(_) => continue

};

println!("You guessed : {}", guess_number);

match guess_number.cmp(&secret_number)

{

cmp::Ordering::Less => println!("Too small!"),

cmp::Ordering::Greater => println!("Too big!"),

cmp::Ordering::Equal =>

{

println!("You win!");

break;

}

test_project.zip

[RUST/COMMON] 튜플에서 구조 해체 사용하기

■ 튜플에서 구조 해체를 사용하는 방법을 보여준다. ▶ 예제 코드 (RS)


let tuple : (i32, f64, i32) = (500, 6.4, 1);

let (x, y, z) = tuple;

println!("{}, {}, {}", x, y, z);

let tuple : (i32, f64, i32) = (500, 6.4, 1);

let (x, y, z) = tuple;

println!("{}, {}, {}", x, y, z);

[RUST/COMMON] Ord 트레잇 : cmp 메소드를 사용해 숫자 비교하기

■ Ord 트레잇의 cmp 메소드를 사용해 숫자를 비교하는 방법을 보여준다. ▶ 예제 코드 (RS)


use std::cmp;

let a : u32 = 10;
let b : u32 = 20;

match a.cmp(&b)
{
    cmp::Ordering::Less    => println!("A가 B보다 작다."),
    cmp::Ordering::Greater => println!("A가 B보다 크다."),
    cmp::Ordering::Equal   => println!("A와 B가 같다.")
}

use std::cmp;

let a : u32 = 10;

let b : u32 = 20;

match a.cmp(&b)

{

cmp::Ordering::Less => println!("A가 B보다 작다."),

cmp::Ordering::Greater => println!("A가 B보다 크다."),

cmp::Ordering::Equal => println!("A와 B가 같다.")

}

[RUST/COMMON] cargo new 명령 : 프로젝트 생성하기

■ cargo new 명령을 사용해 프로젝트를 생성하는 방법을 보여준다. 1. [명령 프롬프트]를 실행한다. 2. [명령 프롬프트]에서 아래 명령을 실행한다. ▶ 실행 명령

[RUST/RAND] ThreadRng 구조체 : gen_range 메소드를 사용해 임의의 난수 구하기

■ ThreadRng 구조체의 gen_range 메소드를 사용해 임의의 난수를 구하는 방법을 보여준다. ▶ 예제 코드 (RS)


use rand::rngs;
use rand::Rng;

let mut thread_rng : rngs::ThreadRng = rand::thread_rng();

let secret_number : u32 = thread_rng.gen_range(1..=100);

use rand::rngs;

use rand::Rng;

let mut thread_rng : rngs::ThreadRng = rand::thread_rng();

let secret_number : u32 = thread_rng.gen_range(1..=100);

[RUST/COMMON] Iterator 트레잇 : map 메소드를 사용해 분할 문자열 벡터 구하기

■ Iterator 트레잇의 map 메소드를 사용해 분할 문자열 벡터를 구하는 방법을 보여준다. ▶ 예제 코드 (RS)


use std::str;

let source : &str = "가가가,나나나,다다다";

let split :str::Split<'_, &str> = source.split(",");

let string_vector : Vec<String> = split.map(|s| s.to_string()).collect();

println!("{:?}", string_vector);

use std::str;

let source : &str = "가가가,나나나,다다다";

let split :str::Split<'_, &str> = source.split(",");

let string_vector : Vec<String> = split.map(|s| s.to_string()).collect();

println!("{:?}", string_vector);

[RUST/COMMON] &str 타입 : split 메소드를 사용해 분할 문자열 벡터 구하기

■ &str 타입의 split 메소드를 사용해 분할 문자열 벡터를 구하는 방법을 보여준다. ▶ 예제 코드 (RS)


let source : &str = "가가가,나나나,다다다";

let mut string_vector : Vec<String> = vec![];

for line in source.split(",")
{
    string_vector.push(line.to_string());
}

println!("{:?}", string_vector);

let source : &str = "가가가,나나나,다다다";

let mut string_vector : Vec<String> = vec![];

for line in source.split(",")

{

string_vector.push(line.to_string());

}

println!("{:?}", string_vector);

[RUST/COMMON] AES 암호화 도구 만들기

■ AES 암호화 도구를 만드는 방법을 보여준다. ▶ Cargo.toml


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

[dependencies]
aes = "0.7.5"
block-modes = "0.8.1"
base64 = "0.13.0"
sha2 = "0.9.8"
getrandom = "0.2.3"

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

aes = "0.7.5"

block-modes = "0.8.1"

base64 = "0.13.0"

sha2 = "0.9.8"

getrandom = "0.2.3"

▶ src/cipher.rs


use aes;
use block_modes;
use block_modes::block_padding;
use block_modes::BlockMode;
use sha2;
use sha2::Digest;

type AesCbc = block_modes::Cbc<aes::Aes256, block_padding::Pkcs7>;

const SALT : &str = "LFsMH#kL!IfY:dcEz9F/dvj17nUN";

pub fn encrypt(plain_text : &str, password : &str, initial_value_byte_vector : &Vec<u8>) -> String
{
    let key_byte_vector : Vec<u8> = get_key_byte_vector(password);

    let cbc : block_modes::Cbc<aes::Aes256, block_padding::Pkcs7> = AesCbc::new_from_slices(&key_byte_vector, &initial_value_byte_vector).unwrap();

    let encrypted_byte_vector : Vec<u8> = cbc.encrypt_vec(plain_text.as_bytes());

    let encrypted_text : String =  base64::encode(encrypted_byte_vector);

    return encrypted_text;
}

pub fn decrypt(encrypted_text : &str, password : &str, initial_value_byte_vector : &Vec<u8>) -> String
{
    let key_byte_vector : Vec<u8> = get_key_byte_vector(password);

    let encrypted_byte_vector : Vec<u8> = base64::decode(encrypted_text).unwrap();

    let cbc : block_modes::Cbc<aes::Aes256, block_padding::Pkcs7> = AesCbc::new_from_slices(&key_byte_vector, initial_value_byte_vector).unwrap();

    let plain_byte_vector : Vec<u8> = cbc.decrypt_vec(&encrypted_byte_vector).unwrap();

    return String::from_utf8(plain_byte_vector).unwrap();
}

fn get_key_byte_vector(password : &str) -> Vec<u8>
{
    let password_salt : String = format!("{}::{}", password, SALT);

    let mut sha256 : sha2::Sha256 = sha2::Sha256::new();

    sha256.update(password_salt.as_bytes());

    return sha256.finalize().to_vec();
}

pub fn get_initial_value_byte_vector() -> Vec<u8>
{
    let mut initial_value_byte_vector : Vec<u8> = vec!
    [
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0
    ];

    getrandom::getrandom(&mut initial_value_byte_vector).unwrap();

    return initial_value_byte_vector;
}

use aes;

use block_modes;

use block_modes::block_padding;

use block_modes::BlockMode;

use sha2;

use sha2::Digest;

type AesCbc = block_modes::Cbc<aes::Aes256, block_padding::Pkcs7>;

const SALT : &str = "LFsMH#kL!IfY:dcEz9F/dvj17nUN";

pub fn encrypt(plain_text : &str, password : &str, initial_value_byte_vector : &Vec<u8>) -> String

{

let key_byte_vector : Vec<u8> = get_key_byte_vector(password);

let cbc : block_modes::Cbc<aes::Aes256, block_padding::Pkcs7> = AesCbc::new_from_slices(&key_byte_vector, &initial_value_byte_vector).unwrap();

let encrypted_byte_vector : Vec<u8> = cbc.encrypt_vec(plain_text.as_bytes());

let encrypted_text : String = base64::encode(encrypted_byte_vector);

return encrypted_text;

}

pub fn decrypt(encrypted_text : &str, password : &str, initial_value_byte_vector : &Vec<u8>) -> String

{

let key_byte_vector : Vec<u8> = get_key_byte_vector(password);

let encrypted_byte_vector : Vec<u8> = base64::decode(encrypted_text).unwrap();

let cbc : block_modes::Cbc<aes::Aes256, block_padding::Pkcs7> = AesCbc::new_from_slices(&key_byte_vector, initial_value_byte_vector).unwrap();

let plain_byte_vector : Vec<u8> = cbc.decrypt_vec(&encrypted_byte_vector).unwrap();

return String::from_utf8(plain_byte_vector).unwrap();

}

fn get_key_byte_vector(password : &str) -> Vec<u8>

{

let password_salt : String = format!("{}::{}", password, SALT);

let mut sha256 : sha2::Sha256 = sha2::Sha256::new();

sha256.update(password_salt.as_bytes());

return sha256.finalize().to_vec();

}

pub fn get_initial_value_byte_vector() -> Vec<u8>

{

let mut initial_value_byte_vector : Vec<u8> = vec!

[

0, 0, 0, 0,

0, 0, 0, 0

];

getrandom::getrandom(&mut initial_value_byte_vector).unwrap();

return initial_value_byte_vector;

}

▶ src/main.rs


use std::env;

mod cipher;

fn main()
{
    let argument_vector : Vec<String> = env::args().collect();

    if argument_vector.len() < 4
    {
        print_usage_message();

        return;
    }

    let method   : String = String::from(argument_vector[1].trim());
    let password : String = String::from(argument_vector[2].trim());
    let source   : String = String::from(argument_vector[3].trim());

    let initial_value_byte_vector : Vec<u8> = cipher::get_initial_value_byte_vector();

    let target : String = match &method[..]
    {
        "enc" => cipher::encrypt(&source, &password, &initial_value_byte_vector),

        "dec" => cipher::decrypt(&source, &password, &initial_value_byte_vector),

        _     =>
        {
            print_usage_message();

            return;
        }
    };

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

fn print_usage_message()
{
    println!("[USAGE] test_project (enc|dec) password source");
}

use std::env;

mod cipher;

fn main()

{

let argument_vector : Vec<String> = env::args().collect();

if argument_vector.len() < 4

{

print_usage_message();

return;

}

let method : String = String::from(argument_vector[1].trim());

let password : String = String::from(argument_vector[2].trim());

let source : String = String::from(argument_vector[3].trim());

let initial_value_byte_vector : Vec<u8> = cipher::get_initial_value_byte_vector();

let target : String = match &method[..]

{

"enc" => cipher::encrypt(&source, &password, &initial_value_byte_vector),

"dec" => cipher::decrypt(&source, &password, &initial_value_byte_vector),

_ =>

{

print_usage_message();

return;

}

};

println!("{}", target);

}

fn print_usage_message()

{

println!("[USAGE] test_project (enc|dec) password source");

}

test_project.zip

[RUST/COMMON] 크레이트 설치 : getrandom

■ getrandom 크레이트를 설치하는 방법을 보여준다. ▶ Cargo.toml


...

[dependencies]
getrandom = "0.2.3"

...

[dependencies]

getrandom = "0.2.3"

[RUST/COMMON] 크레이트 설치 : sha2

■ sha2 크레이트를 설치하는 방법을 보여준다. ▶ Cargo.toml


...

[dependencies]
sha2 = "0.9.8"

...

[dependencies]

sha2 = "0.9.8"

[RUST/COMMON] 크레이트 설치 : block-modes

■ block-modes 크레이트를 설치하는 방법을 보여준다. ▶ Cargo.toml


...

[dependencies]
block-modes = "0.8.1"

...

[dependencies]

block-modes = "0.8.1"

[RUST/COMMON] 크레이트 설치 : base64

■ base64 크레이트를 설치하는 방법을 보여준다. ▶ Cargo.toml


...

[dependencies]
base64 = "0.13.0"

...

[dependencies]

base64 = "0.13.0"

[RUST/COMMON] 크레이트 설치 : aes

■ aes 크레이트를 설치하는 방법을 보여준다. ▶ Cargo.toml


...

[dependencies]
aes = "0.7.5"

...

[dependencies]

aes = "0.7.5"

[RUST/REQWEST] get 함수 : 이미지 파일 다운로드하기

■ get 함수를 사용해 이미지 파일을 다운로드하는 방법을 보여준다. ▶ Cargo.toml


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

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

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

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

reqwest = "0.11.4"

▶ src/main.rs


use std::fs;
use std::io::Write;

#[tokio::main]
async fn main()
{
    let source_url : &str = "https://blog.kakaocdn.net/dn/bcZgvb/btskiAmI1cg/pm8rWnRjBTkMnvYcxNDgDk/img.png";

    let target_bytes = reqwest::get(source_url).await.unwrap().bytes().await.unwrap();

    let target_file_path : &str = "download.png";

    let mut file : fs::File = fs::File::create(target_file_path).unwrap();

    file.write_all(&target_bytes).unwrap();
}

use std::fs;

use std::io::Write;

#[tokio::main]

async fn main()

{

let source_url : &str = "https://blog.kakaocdn.net/dn/bcZgvb/btskiAmI1cg/pm8rWnRjBTkMnvYcxNDgDk/img.png";

let target_bytes = reqwest::get(source_url).await.unwrap().bytes().await.unwrap();

let target_file_path : &str = "download.png";

let mut file : fs::File = fs::File::create(target_file_path).unwrap();

file.write_all(&target_bytes).unwrap();

}

test_project.zip

[RUST/SCRAPER] HTML 문자열 파싱하기

■ HTML 문자열을 파싱하는 방법을 보여준다. ▶ Cargo.toml


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

[dependencies]
scraper = "0.12"

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

scraper = "0.12"

▶ src/main.rs


use scraper;

fn main()
{
    let html_string : &str = "<html><body><p>테스트 문자열 1</p><p>테스트 문자열 1</p></body></html>";

    let html : scraper::Html = scraper::Html::parse_document(&html_string);

    let selector : scraper::Selector = scraper::Selector::parse("p").unwrap();

    for (index, element) in html.select(&selector).enumerate()
    {
        println!("{} : {:?}", index, element.value());
    }
}

use scraper;

fn main()

{

let html_string : &str = "<html><body><p>테스트 문자열 1</p><p>테스트 문자열 1</p></body></html>";

let html : scraper::Html = scraper::Html::parse_document(&html_string);

let selector : scraper::Selector = scraper::Selector::parse("p").unwrap();

for (index, element) in html.select(&selector).enumerate()

{

println!("{} : {:?}", index, element.value());

}

test_project.zip

[RUST/REQWEST] get 함수 : 웹 페이지 다운로드하기

■ get 함수를 사용해 웹 페이지를 다운로드하는 방법을 보여준다. ▶ Cargo.toml


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

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

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

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

reqwest = "0.11.4"

▶ src/main.rs


#[tokio::main]
async fn main()
{
    let html : String = reqwest::get("https://icodebroker.tistory.com")
        .await.unwrap()
        .text().await.unwrap();

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

#[tokio::main]

async fn main()

{

let html : String = reqwest::get("https://icodebroker.tistory.com")

.await.unwrap()

.text().await.unwrap();

println!("{}", html);

}

test_project.zip

[RUST/URLENCODING] encode 함수 : URL 인코딩 문자열 구하기

■ encode 함수를 사용해 URL 인코딩 문자열을 구하는 방법을 보여준다 ▶ 예제 코드 (RS)


use std::borrow;

let url_encoded_cow : borrow::Cow<'_, str> = urlencoding::encode("테스트 1234");

println!("{}", url_encoded_cow);

/*
%ED%85%8C%EC%8A%A4%ED%8A%B8%201234
*/

use std::borrow;

let url_encoded_cow : borrow::Cow<'_, str> = urlencoding::encode("테스트 1234");

println!("{}", url_encoded_cow);

%ED%85%8C%EC%8A%A4%ED%8A%B8%201234

[RUST/REQWEST] 웹 사이트에서 이미지 파일 다운로드하기

■ 웹 사이트에서 이미지 파일을 다운로드하는 방법을 보여준다. ▶ Cargo.toml


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

[dependencies]
tokio = { version = "1", features = ["full"] }
reqwest = "0.11.4"
scraper = "0.12"
urlencoding = "2.1"

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

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

reqwest = "0.11.4"

scraper = "0.12"

urlencoding = "2.1"

▶ src/main.rs


use std::fs;
use std::io::Write;

use scraper;
use tokio::time;

#[tokio::main]
async fn main()
{
    for title in ["test", "yiy"]
    {
        download_images_async(title).await;
    }
}

async fn download_images_async(title : &str)
{
    let root_url : &str = "https://uta.pw/shodou";

    let url : String = format!
    (
        "{}/index.php?titles&show&title={}",
        root_url,
        urlencoding::encode(title)
    );

    println!("GET : {}", url);

    let html_string : String = reqwest::get(url).await.unwrap().text().await.unwrap();

    let html : scraper::Html = scraper::Html::parse_document(&html_string);

    let selector : scraper::Selector = scraper::Selector::parse(".articles img").unwrap();

    for(index, element) in html.select(&selector).enumerate()
    {
        let source : &str = element.value().attr("src").unwrap();

        let img_url : String = format!("{}/{}", root_url, source);

        println!("{}", img_url);

        let file_name : String = format!("{}_{}.png", title, index);

        let bytes = reqwest::get(img_url).await.unwrap().bytes().await.unwrap();

        let mut file : fs::File = fs::File::create(file_name).unwrap();

        file.write_all(&bytes).unwrap();

        time::sleep(time::Duration::from_millis(1000)).await;
    }
}

use std::fs;

use std::io::Write;

use scraper;

use tokio::time;

#[tokio::main]

async fn main()

{

for title in ["test", "yiy"]

{

download_images_async(title).await;

}

async fn download_images_async(title : &str)

{

let root_url : &str = "https://uta.pw/shodou";

let url : String = format!

(

"{}/index.php?titles&show&title={}",

root_url,

urlencoding::encode(title)

);

println!("GET : {}", url);

let html_string : String = reqwest::get(url).await.unwrap().text().await.unwrap();

let html : scraper::Html = scraper::Html::parse_document(&html_string);

let selector : scraper::Selector = scraper::Selector::parse(".articles img").unwrap();

for(index, element) in html.select(&selector).enumerate()

{

let source : &str = element.value().attr("src").unwrap();

let img_url : String = format!("{}/{}", root_url, source);

println!("{}", img_url);

let file_name : String = format!("{}_{}.png", title, index);

let bytes = reqwest::get(img_url).await.unwrap().bytes().await.unwrap();

let mut file : fs::File = fs::File::create(file_name).unwrap();

file.write_all(&bytes).unwrap();

time::sleep(time::Duration::from_millis(1000)).await;

}

test_project.zip

[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/COMMON] 크레이트 설치 : urlencoding

■ urlencoding 크레이트를 설치하는 방법을 보여준다. ▶ Cargo.toml


...

[dependencies]
urlencoding = "2.1"

...

[dependencies]

urlencoding = "2.1"

[RUST/COMMON] 크레이트 설치 : scraper

■ scraper 크레이트를 설치하는 방법을 보여준다. ▶ Cargo.toml


...

[dependencies]
scraper = "0.12"

...

[dependencies]

scraper = "0.12"

[RUST/COMMON] 크레이트 설치 : reqwest

■ reqwest 크레이트를 설치하는 방법을 보여준다. ▶ Cargo.toml


...

[dependencies]
reqwest = "0.11.4"

...

[dependencies]

reqwest = "0.11.4"

[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