Início / coding / Perguntas / 79313959
Accepted
user2138149
Asked: 2024-12-28 22:36:53 +0800 CST

Como compartilhar um sinalizador booleano com um thread com escopo em Rust?

  • 772

Estou tentando usar um sinalizador booleano para sinalizar que um thread deve sair. No entanto, atualmente meu código viola as regras do verificador de empréstimo. Eu entendo por que ele viola essas regras, no entanto, o que eu não sei é qual é o design mais apropriado e como isso pode corrigir o problema.

fn long_running(exit_flag: &bool) {

    loop {
        std::thread::sleep(std::time::Duration::from_secs(10));

        if *exit_flag {
            break;
        }
    }
}

fn main() {

    let mut exit_flag = false;
    std::thread::scope(
        |scope| {
            let handle = scope.spawn(
                || {
                    long_running(&exit_flag); # (1)
                }
            );

            exit_flag = true; # (2)

            // terminate the consumer poll loop
            handle.join().expect("failed to join thread");
        }
    );
}

O problema envolve as linhas marcadas com # (1)e # (2).

  • # (1): A referência a exit_flagé emprestada
  • # (2): Tentando mutar a variável subjacente enquanto a referência ainda está emprestada

Isso não é permitido devido às regras do verificador de empréstimos.

  • Uma solução para o problema pode ser alocar o sinalizador em heap e usá-lo para compartilhar os dados entre os dois threads.
  • Entretanto, a intenção de uso std::thread::scopeera permitir o lançamento de um thread que tenha acesso a uma variável local da pilha do thread pai (principal).

a propósito, tive a ideia de fazer isso neste tópico

multithreading

1 respostas

  1. Best Answer

    Isso não funciona porque exit_flagdeve ser emprestado pelo fechamento do thread enquanto também está sendo mutado via exit_flag = true;. Em outras palavras, não há garantia de que o thread tenha parado de observar exit_flagenquanto está sendo mutado (que na verdade é o ponto principal de exit_flag).

    Você precisará de um AtomicBoolpara fazer isso:

    use std::sync::atomic::{AtomicBool, Ordering};

fn long_running(exit_flag: &AtomicBool) {
    loop {
        println!("Working...");
        std::thread::sleep(std::time::Duration::from_secs(3));
        if exit_flag.load(Ordering::Relaxed) {
            break;
        }
    }
}

fn main() {
    let exit_flag = AtomicBool::new(false);
    std::thread::scope(|scope| {
        scope.spawn(|| {
            long_running(&exit_flag);
        });
        exit_flag.store(true, Ordering::Relaxed);
    });
    println!("Done");
}

    Observe que removi handle.join(), pois thread::scopejá garante que todos os threads foram unidos quando ele retornar.

    • 6

relate perguntas