Início / coding / Perguntas / 77045342
Accepted
Saber
Asked: 2023-09-05 22:21:53 +0800 CST

Um println extra no thread principal faz com que o Rust execute resultados diferentes

  • 772

Encontrei um fenômeno ao aprender multithreading Rust tokio, não sei por quê。

Aqui está o código.

use std::{thread, time::Duration};

use chrono::Local;

fn now() -> String {
    Local::now().format("%F %T").to_string()
}

async fn async_task(i: u64) {
    thread::sleep(Duration::from_secs(i));
    println!("{}.async task {}!", now(), i);
}
#[tokio::main]
async fn main() {
    for i in 0..10 {
        tokio::spawn(async_task(i));
    }
    println!("{}.main thread", now());
}

Executei o código e descobri que cada 10 tarefas assíncronas foram executadas. O resultado foi ao vivo abaixo

2023-09-05 22:08:05.async task 0!
2023-09-05 22:08:05.main thread
2023-09-05 22:08:06.async task 1!
2023-09-05 22:08:07.async task 2!
2023-09-05 22:08:08.async task 3!
2023-09-05 22:08:09.async task 4!
2023-09-05 22:08:10.async task 5!
2023-09-05 22:08:11.async task 6!
2023-09-05 22:08:12.async task 7!
2023-09-05 22:08:13.async task 8!
2023-09-05 22:08:14.async task 9!

Quando comento o printlncódigo no mainthread, apenas algumas tarefas serão executadas.

#[tokio::main]
async fn main() {
    for i in 0..10 {
        tokio::spawn(async_task(i));
    }
    // println!("{}.main thread", now());
}

O resultado foi ao vivo abaixo

2023-09-05 22:10:51.async task 0!
2023-09-05 22:10:52.async task 1!

Já tentei isso muitas vezes e sempre ocorre essa diferença. Em cada tentativa, o código que não comenta printlnexecuta todas as tarefas assíncronas e o outro não.

Eu realmente não entendo por que um printlnpoderia fazer uma diferença tão grande. Eu apreciaria se alguém pudesse ajudar.

multithreading

1 respostas

  1. Best Answer

    A verdadeira razão pela qual seu código se comporta de maneira estranha é porque você usa std::thread::sleepem vez de tokio::time::sleep.

    É importante ao trabalhar com funções assíncronas que você nunca bloqueia. Os reatores assíncronos não são preemptivos , o que significa que só podem agendar entre tarefas em .awaitalguns pontos. Isso significa que, se você std::thread::sleepbloquear o programa inteiro. É também por isso que no seu programa de trabalho a saída nem sempre é impressa na ordem correta, embora o tempo deva ser de um segundo inteiro entre cada impressão.

    Se você substituir std::thread::sleeppor tokio::time::sleep, obterá um comportamento consistente (embora provavelmente não seja o comportamento desejado):

    use std::time::Duration;

use chrono::Local;

fn now() -> String {
    Local::now().format("%F %T").to_string()
}

async fn async_task(i: u64) {
    tokio::time::sleep(Duration::from_secs(i)).await;
    println!("{}.async task {}!", now(), i);
}
#[tokio::main]
async fn main() {
    for i in 0..10 {
        tokio::spawn(async_task(i));
    }
    println!("{}.main thread", now());
    tokio::time::sleep(Duration::from_millis(2500)).await;
}

    2023-09-05 16:39:25.main thread
2023-09-05 16:39:25.async task 0!
2023-09-05 16:39:26.async task 1!
2023-09-05 16:39:27.async task 2!

    Por quê então? Porque quando maintermina, o Tokio cancela todas as tarefas restantes. Mas, novamente, o tokio só pode agendar em .awaitpontos, então no seu exemplo de 'trabalho', o tokio ainda tenta cancelar as tarefas, mas não tem sucesso porque elas nunca atingem um .awaitponto. Então ‘parece’ que Tóquio está esperando por eles, mas isso não é verdade.

    A maneira mais simples de resolver isso é não mainencerrar a função. (na verdade, esta é a única maneira que me vem à mente)

    Existem várias maneiras de conseguir isso. No seu caso, me parece que sua intenção é aguardar o término de todas as subtarefas, para então encerrar o programa. Isso pode ser feito aguardando os identificadores de junção:

    use std::time::Duration;

use chrono::Local;

fn now() -> String {
    Local::now().format("%F %T").to_string()
}

async fn async_task(i: u64) {
    tokio::time::sleep(Duration::from_secs(i)).await;
    println!("{}.async task {}!", now(), i);
}
#[tokio::main]
async fn main() {
    let mut joinhandles = Vec::new();
    for i in 0..10 {
        joinhandles.push(tokio::spawn(async_task(i)));
    }

    println!("{}.main thread", now());

    for joinhandle in joinhandles {
        joinhandle.await.unwrap();
    }
}

    2023-09-05 16:47:23.main thread
2023-09-05 16:47:23.async task 0!
2023-09-05 16:47:24.async task 1!
2023-09-05 16:47:25.async task 2!
2023-09-05 16:47:26.async task 3!
2023-09-05 16:47:27.async task 4!
2023-09-05 16:47:28.async task 5!
2023-09-05 16:47:29.async task 6!
2023-09-05 16:47:30.async task 7!
2023-09-05 16:47:31.async task 8!
2023-09-05 16:47:32.async task 9!

    Dito isto, aguardá-los um por um é um pouco tedioso e também evita a propagação imediata de erros. Em vez disso, você poderia usar futures::future::try_join_all:

    use std::time::Duration;

use chrono::Local;

fn now() -> String {
    Local::now().format("%F %T").to_string()
}

async fn async_task(i: u64) {
    tokio::time::sleep(Duration::from_secs(i)).await;
    println!("{}.async task {}!", now(), i);
}
#[tokio::main]
async fn main() {
    // Same as the for-loop in the earlier example,
    // just more compact and functional
    let joinhandles = (0..10)
        .map(|i| tokio::spawn(async_task(i)))
        .collect::<Vec<_>>();

    println!("{}.main thread", now());

    futures::future::try_join_all(joinhandles).await.unwrap();
}

    2023-09-05 16:56:14.main thread
2023-09-05 16:56:14.async task 0!
2023-09-05 16:56:15.async task 1!
2023-09-05 16:56:16.async task 2!
2023-09-05 16:56:17.async task 3!
2023-09-05 16:56:18.async task 4!
2023-09-05 16:56:19.async task 5!
2023-09-05 16:56:20.async task 6!
2023-09-05 16:56:21.async task 7!
2023-09-05 16:56:22.async task 8!
2023-09-05 16:56:23.async task 9!
    • 3

relate perguntas