-2

例如，我希望每个线程在前一个线程完成之前不开始运行，是否有一个标志，比如thread.isRunning()？

#include <iostream>
#include <vector>
#include <thread>
using namespace std;

void hello() {
    cout << "thread id: " << this_thread::get_id() << endl;
}

int main() {

    vector<thread> threads;

    for (int i = 0; i < 5; ++i)
        threads.push_back(thread(hello));


    for (thread& thr : threads)
        thr.join();

    cin.get();
    return 0;
}

我知道线程是要同时运行的，但是如果我想控制顺序怎么办？

4

7 回答 7

3

没有thread.isRunning()。你需要一些同步原语来做到这一点。例如考虑std::condition_variable。

于 2013-08-12T12:59:42.037 回答
3

一种可行的方法是使用std::async。当前的定义std::async是，由 std::async 启动的操作的关联状态会导致返回std::future的 的析构函数阻塞，直到操作完成。这可能会限制可组合性并导致代码看似并行运行，但实际上是按顺序运行。

{
    std::async(std::launch::async, []{ hello(); });
    std::async(std::launch::async, []{ hello(); });  // does not run until hello() completes
}
于 2013-08-12T13:08:49.237 回答
2

如果我们需要在第一个线程完成后开始运行第二个线程，那么真的需要线程吗？

对于解决方案，我认为尝试设置一个全局标志，在第一个线程中设置值，然后在启动第二个线程时，首先检查标志应该有效。

于 2013-08-12T12:59:13.950 回答
2

您不能像说“首先，线程 1，然后线程 2，......”这样简单地控制顺序，您需要使用同步（即std::mutex条件变量std::condition_variable_any）。
您可以创建事件以阻塞一个线程，直到某个事件发生。

有关C++-11 中线程机制的概述，请参阅cppreference 。

于 2013-08-12T12:59:46.457 回答
0

您将需要使用信号量或锁。
如果将信号量初始化为值 0：
在 thread.start() 之后调用 wait 并在线程执行函数结束时调用 signal/release（例如 java 中的运行函数、OnExit 函数等...）

所以主线程将一直等待，直到循环中的线程完成执行。

于 2013-08-12T13:07:31.437 回答
0

基于任务的并行性可以实现这一点，但 C++ 目前不提供任务模型作为其线程库的一部分。如果您有 TBB 或 PPL，您可以使用他们的基于任务的工具。

于 2013-08-12T13:54:24.310 回答
0

我认为你可以通过使用C++11std::mutex来实现这一点。std::condition_variable为了能够在使用的布尔数组中顺序运行线程，当线程完成一些工作时，它会写入true数组的特定索引。例如：

mutex mtx;
condition_variable cv;
int ids[10] = { false };

void shared_method(int id) {
    unique_lock<mutex> lock(mtx);

    if (id != 0) {
        while (!ids[id - 1]) {
            cv.wait(lock);
        }
    }

    int delay = rand() % 4;
    cout << "Thread " << id << " will finish in " << delay << " seconds." << endl;
    this_thread::sleep_for(chrono::seconds(delay));

    ids[id] = true;
    cv.notify_all();
}

void test_condition_variable() {    
    thread threads[10];

    for (int i = 0; i < 10; ++i) {
        threads[i] = thread(shared_method, i);
    }

    for (thread &t : threads) {
        t.join();
    }
}

输出：

Thread 0 will finish in 3 seconds.
Thread 1 will finish in 1 seconds.
Thread 2 will finish in 1 seconds.
Thread 3 will finish in 2 seconds.
Thread 4 will finish in 2 seconds.
Thread 5 will finish in 0 seconds.
Thread 6 will finish in 0 seconds.
Thread 7 will finish in 2 seconds.
Thread 8 will finish in 3 seconds.
Thread 9 will finish in 1 seconds.
于 2019-08-01T08:31:24.267 回答