WaitForMultipleObjects alternative with std::thread?

Question

My problem is that I have multiple threads, they are stored in some container, and I need to know when a thread at a certain position finished. On windows I would do something like:

HANDLE handles[3];
//handles were initialized
DWORD finishingThread = WaitForMultipleObjects(3, handles, false, INFINITE)

Is there any way to achieve the same effect with std::thread?

Look in here: http://stackoverflow.com/questions/10818254/learning-threads-on-linux — marcinj, Jan 31 '14 at 08:45
@marcin_j that question isn't just informative, It is arguably an outright-dupe of this one (or rather it is the other way around). Thanks for linking it. And to the OP, no, not natively without some work on your part. Such an arbitrary thread-exit-detection isn't in the thread-support library, at least not that I've ever seen. — WhozCraig, Jan 31 '14 at 08:48
if you're on windows and want to just keep it more C++ish then the [Concurrency Runtime](http://msdn.microsoft.com/en-us/library/dd504870.aspx) is a good choice. Microsoft's `std::thread` and `std::async` implementation is built on top of it in VS2013. — Mgetz, Jan 31 '14 at 20:40

score 6 · Answer 1 · answered Jan 31 '14 at 09:16

To the very best of my knowledge, there is nothing in the standard library that supports a wait of that nature. The standard library is built on top of the underlying operating system threading support. By necessity the standard library can only offer lowest common denominator functionality. Which means that it is not able to wrap some of the richer functionality offered by the Win32 threading library.

score 2 · Answer 2 · answered Jan 31 '14 at 21:15

2

Just use a std::condition_variable and have your threads fire notify_all() or notify_one() right before they finish.

Then do cv.wait() where you want your WaitForMultipleObjects() call.

answered Jan 31 '14 at 21:15

Nick Strupat

4,928
4
44
56

3

This is not an answer to the question because std::condition_variable allows to notify one or more waiting threads about the state of a particular object (in particular thread). The WaitForMultipleObjects() allows one thread to be notified about the states of multiple objects in multiple threads. – Jurlie Jan 11 '18 at 02:15

Felix Glas · Answer 3 · 2021-11-06T21:08:12.197

Here's an example of how you can achieve the same effect using std::thread and std::future if you are willing to let the main thread sleep while polling the readiness of the threads (alternatively you could let a dedicated thread handle the waiting).

Consider this function, taking a range of iterators to a container of std::future, which will block until at least one task is finished:

const int TIME_BETWEEN_POLLS_MS = 50;

// Wait (sleep) between polls until a task is finished then return iterator to future.
template <typename Iterator>
Iterator waitForFirst(Iterator first, Iterator last) {
    auto it = first;
    auto status = std::future_status::timeout;
    while (status != std::future_status::ready) {
        if (++it == last) { // Rotate in range.
            it = first;
        }
        status = it->wait_for(std::chrono::milliseconds(TIME_BETWEEN_POLLS_MS));
    }
    return it;
}

Now if you have a container of futures (std::future) associated with the return values of your tasks running on separate threads, you can simply use the function waitForFirst to get an iterator to the future that gets its result first.

    // Lets say you have a vector of futures, e.g.
    std::vector<std::future<std::thread::id>> futures;

    /* Push futures to vector... */

    // Block until first task is finished.
    // 'it' is iterator to future associated with result.
    auto it = waitForFirst(std::begin(futures), std::end(futures));

See live example

oblitum · Answer 4 · 2014-01-31T20:35:49.327

1

Try Async++ Composition which is a reference implementation for the N3428 C++ standard proposal.

This article is relevant before that:

Broken promises–C++0x futures

In an unportable way you can also call std::thread::native_handle() to use WaitForMultipleObjects with the return.

edited Jan 31 '14 at 20:35

answered Jan 31 '14 at 20:28

oblitum

11,380
6
54
120

score 0 · Answer 5 · answered Jul 18 '23 at 20:07

kinda late, but here is an example (for windows):

#include <Windows.h>
#include <thread>





std::shared_ptr<bool> val1 = std::make_shared<bool>(0);
std::shared_ptr<bool> val2 = std::make_shared<bool>(0);

void thread(std::shared_ptr<bool> val) {
    *val = true;
    OutputDebugString(L"\n\nthread\n\n");
    return;
}

int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE useless, PWSTR cmdLine, int nCmdShow) {


    *val1 = false;
    *val2 = false;
    std::thread tr1(thread, val1);
    std::thread tr2(thread, val2);

    tr1.detach();
    tr2.detach();

    while (!(*val1) || !(*val2)) {
        OutputDebugString(L"WAIT\n");
    };

    OutputDebugString(L"\n\nFinished\n\n");


    return 0;
}

score -3 · Answer 6 · answered Jan 31 '14 at 09:46

What you want is something equivalent to boost::thread_group.

Doesn't exist, but you can write that functionality: A std::vector and std::for_each to call join()/WaitForSingleObject on each element, or of course search for a 3rd party that does the same like cppthreadpool

WaitForMultipleObjects alternative with std::thread?

6 Answers6