std :: thread:如何等待(join)任何给定的线程完成?

时间:2017-04-25 15:13:47

标签: c++ multithreading c++11

例如,我有两个主题t1t2。我想等待t1 t2完成。这可能吗?

如果我有一系列主题,比如std::vector<std::thread>,我该怎么办呢?

4 个答案:

答案 0 :(得分:3)

总是等待&amp;使用std::condition_variable例如

通知
std::mutex m;
std::condition_variable cond;
std::atomic<std::thread::id> val;

auto task = [&] {
    std::this_thread::sleep_for(1s); // Some work

    val = std::this_thread::get_id();
    cond.notify_all();
};

std::thread{task}.detach();
std::thread{task}.detach();
std::thread{task}.detach();

std::unique_lock<std::mutex> lock{m};
cond.wait(lock, [&] { return val != std::thread::id{}; });

std::cout << "Thread " << val << " finished first" << std::endl;

注意: val并不一定代表首先完成的线程,因为所有线程几乎在同一时间完成并且会发生覆盖,但它仅适用于这个例子的目的。

答案 1 :(得分:2)

不,在C ++ 11的线程库中没有等待多个对象。

如果您想等待一组操作中的第一个操作,请考虑让它们为线程安全的生产者 - 消费者队列提供数据。

Here是我制作的包含threaded_queue<T>的帖子。将线程的工作产品交付到这样的队列中。让消费者阅读另一端。

现在有人可以一次等待多个线程的(工作产品)。或一个线程。或GPU着色器。或者通过RESTful Web界面交付工作产品。你不在乎。

线程本身应该由std::thread之上的线程池或其他更高级别的抽象来管理,因为std::thread使得面向客户端的线程抽象不佳。

template<class T>
struct threaded_queue {
  using lock = std::unique_lock<std::mutex>;
  void push_back( T t ) {
    {
      lock l(m);
      data.push_back(std::move(t));
    }
    cv.notify_one();
  }
  boost::optional<T> pop_front() {
    lock l(m);
    cv.wait(l, [this]{ return abort || !data.empty(); } );
    if (abort) return {};
    auto r = std::move(data.back());
    data.pop_back();
    return r;
  }
  void terminate() {
    {
      lock l(m);
      abort = true;
      data.clear();
    }
    cv.notify_all();
  }
  ~threaded_queue()
  {
    terminate();
  }
private:
  std::mutex m;
  std::deque<T> data;
  std::condition_variable cv;
  bool abort = false;
};

我在C ++ 17中使用std::optional而不是boost::optional。它也可以用unique_ptr或许多其他结构替换。

答案 2 :(得分:1)

轮询等待很容易:

#include<iostream>
#include<thread>
#include<random>
#include<chrono>
#include<atomic>

void thread_task(std::atomic<bool> & boolean) {
    std::default_random_engine engine{std::random_device{}()};
    std::uniform_int_distribution<int64_t> dist{1000, 3000};
    int64_t wait_time = dist(engine);
    std::this_thread::sleep_for(std::chrono::milliseconds{wait_time});
    std::string line = "Thread slept for " + std::to_string(wait_time) + "ms.\n";
    std::cout << line;
    boolean.store(true);
}

int main() {
    std::vector<std::thread> threads;
    std::atomic<bool> boolean{false};
    for(int i = 0; i < 4; i++) {
        threads.emplace_back([&]{thread_task(boolean);});
    }
    std::string line = "We reacted after a single thread finished!\n";
    while(!boolean) std::this_thread::yield();
    std::cout << line;
    for(std::thread & thread : threads) {
        thread.join();
    }
    return 0;
}

我在Ideone.com上的输出示例:

Thread slept for 1194ms.
We reacted after a single thread finished!
Thread slept for 1967ms.
Thread slept for 2390ms.
Thread slept for 2984ms.

这可能不是最好的代码,因为轮询循环不一定是最佳实践,但它应该作为一个开始。

答案 3 :(得分:0)

没有标准的方法可以等待多个线程。

您需要在Windows上使用特定于操作系统的功能,例如WaitForMultipleObjects。 仅限Windows的示例:

HANDLE handles[] = { t1.native_handle(), t2.native_handle(),  };
auto res = WaitForMultipleObjects(2 , handles, FALSE, INFINITE);

有趣的是,当std::when_any标准化时,人们可以做出标准但浪费的解决方案:

std::vector<std::thread> waitingThreads;
std::vector<std::future<void>> futures;
for (auto& thread: threads){
    std::promise<void> promise;
    futures.emplace_back(promise.get_future());
    waitingThreads.emplace_back([&thread, promise = std::move(promise)]{
         thread.join();
         promise.set_value();
    });
}

auto oneFinished = std::when_any(futures.begin(), futures.end());

非常浪费,仍然没有,但标准。