Início / coding / Perguntas / 79591514
Accepted
Angle.Bracket
Asked: 2025-04-25 06:00:43 +0800 CST

Por que essa corrotina C++ assíncrona está sempre sendo executada no mesmo thread?

  • 772

Depois de executar este programa

std::future<int> f() {
    std::cout << "enter f on thread " << std::this_thread::get_id() << std::endl;
    co_return 1;
}
std::future<void> g() {
    std::future<int> i = co_await std::async(f);
    std::cout << "resume g on thread: " << std::this_thread::get_id() << std::endl;
    co_return;
}
int main() {
    std::future<void> f;
    while (true) {
        f = g();
        std::this_thread::sleep_for(1s);
    }
    return 0;
}

que foi compilado com MSVC 19.43 usando a /awaitopção, observei que a função festá sempre sendo executada na mesma thread, enquanto a continuação na função gé sempre executada em uma thread recém-criada. Também tentei chamar std::asynccom std::launch::asynca opção para forçar a criação de uma nova thread, mas ainda assim a mesma thread seria usada para executar f. Alguém pode explicar o porquê?

c++

1 respostas

  1. Best Answer

    std::futurenão deveria ter um tipo de promessa em corrotinas C++20, mas isso é uma extensão do MSVC.

    std::async(f);executa a função fem outro thread, todas as implementações principais usam um thread-pool para std::async , citando cppref.

    (potencialmente em um thread separado que pode ser parte de um pool de threads)

    você obteria o mesmo ID de thread com uma função normal, isso não tem nada a ver com corrotinas. você poderia obter uma de N threads no pool, geralmente N é o número de núcleos, parece que o pool MSVC usa a mesma thread sempre que não está ocupado.

    enquanto a continuação na função g é sempre executada em um thread recém-criado.

    sim, a implementação do MSVC do std::futureawaiter cria um novo thread para executar a continuação toda vez, o código a seguir é da biblioteca padrão do MSVC.

     void await_suspend(experimental::coroutine_handle<> _ResumeCb) {
     // TRANSITION, change to .then if and when future gets .then
     thread _WaitingThread([&_Fut = _Fut, _ResumeCb]() mutable {
         _Fut.wait();
         _ResumeCb();
     });
     _WaitingThread.detach();
 }

    um thread é lançado e destacado, que está esperando para executar a continuação, isso acontece quando se aguarda umstd::future

    para resumir o que está acontecendo:

    1. chamadas principais g, a primeira parte é gexecutada no thread principal até o await.
    2. std::async(f)é executado fno threadpool.
    3. await futurelança um novo tópico sobre waito futuro e depois executa a continuação deg
    • 8

relate perguntas