C++；线程库，在完成前两个线程后启动线程 我需要一点帮助，我在C++中使用“线程”库，我想一起启动三个线程，线程1和2必须计算数据，并且我希望在完成前第三个线程。请举例说明

我必须启动3个线程，第三个线程必须在启动时被阻止，并在前一个线程完成工作后等待

#include <thread>

void one() { /* ... */ }
void two() { /* ... */ }
void three() { 

//this one is blocked on start and waiting for finish previus
}


void f()
{
    std::thread t1(one), t2(two), t3(three);
    t1.join();
    t2.join();
    t3.join();


}

#包括
void one（）{/*…*/}
void two（）{/*…*/}
无效三（{
//这一个在开始和等待完成时被阻止
}
void f（）
{
螺纹t1（一）、t2（二）、t3（三）；
t1.join（）；
t2.连接（）；
t3.join（）；
}

不要启动第三个线程。两个工作线程完成后，只需在调用线程中继续：

#include <thread>

void do_work() { /* ... */ }

void f()
{
    std::thread t1(do_work), t2(do_work);
    t1.join();
    t2.join();

    // do final work here
}

#包括
void do_work（）{/*…*/}
void f（）
{
std：：螺纹t1（做工作），t2（做工作）；
t1.join（）；
t2.连接（）；
//在这里做最后的工作
}

您要做的是连接前两个线程，然后在该指令完成时踢第三个线程。您可以看到一个很好的例子，除非您的应用程序保持运行（或是后台进程），否则其他答案应该足够了。这就是你问题中缺少的信息

然而，如果是上述情况，那么您将如何进行：

当某些数据可用时，您的前两个线程将唤醒并开始工作。一旦计算出所需的数据，它将向第三个线程发送一条消息。根据第三个线程正在执行的操作，它要么立即开始处理消息，要么将其排队，以便稍后处理

---

因此，在这个场景中，关键是消息传递和排队。

一个线程在用函子构造后立即启动。因此，如果您不想在前两个步骤完成之前启动

three（）

，您只需延迟构建：

void f()
{
    std::thread t1(one), t2(two);
    t1.join();
    t2.join();

    // ok, 1 and 2 are done, start 3
    std::thread t3(three);
    t3.join();

    // all 3 are done
}

如果您真的想启动线程并阻塞直到t1/t2完成，那么您需要执行以下操作：

void f()
{
    std::condition_variable cv; 
    std::mutex m;

    std::thread t1(one), t2(two);
    std::thread t3([&]{
        std::unique_lock<std::mutex> lk(m);
        cv.wait(lk);

        three();
    });
    t1.join();
    t2.join();

    // ok, 1 and 2 are done, start 3
    {
        // I don't think the lock here is strictly necessary
        std::unique_lock<std::mutex> lk(m);
        cv.notify_all();
    }

    t3.join();
    // all 3 are done
}

void f（）
{
std：：条件变量cv；
std：：互斥m；
标准：螺纹t1（一个），t2（两个）；
标准：线程t3（[&]{
std：：唯一锁lk（m）；
cv.等待（lk）；
三个（）；
});
t1.join（）；
t2.连接（）；
//好的，1和2都完成了，开始3
{
//我认为这里的锁不是绝对必要的
std：：唯一锁lk（m）；
cv.通知所有人（）；
}
t3.join（）；
//所有3个都完成了
}

你们知道自己的思路，但你们没有读过问题。在所有线程完成之前，他没有说过要关闭主程序。只有t3需要等待

代码应仅启动t3。 t3应启动t1和t2 使用t1.join（）等待它们；t2.连接（）；

---

然后执行它的代码。

我编辑了我的问题。如果三个线程必须从主程序启动，这就是答案。我假设t1和t2都与t3共享一个std:：condition_变量。