Suggestions for a simple thread dispatch

[Guest]

I'm looking for a simple way of sending a divided workload to a fixed (maximum) number of threads.

Here is how I do it when the workload is simply divided by the number of threads:

std::vector<std::thread> threads;
for(uint i = 0; i < numThreads; ++i) {
    threads.push_back(std::thread(
        &MyClass::myFunction, this, myData)
    );
}
for(auto& t : threads) { t.join(); }

If the workload was so large, that I wanted to divide it into more pieces than I have hardware threads, it's probably not so good to do the following, right?

for(uint i = 0; i < numPieces; ++i) {
    threads.push_back(...);
}

Is there a minimalist way of dispatching the workload (over time) without using more than numThreads at once? I tried to think of ways to join finished threads using mutexes, atomics, queues, but the code always becomes bloated rather quickly. Maybe someone here has experience with threads and can point to an elegant solution.

Thanks!

[manasij7479]

You might want to use std::async .
std::async - cppreference.com

If both the std::launch::async and std::launch::deferred flags are set in policy, it is up to the implementation whether to perform asynchronous execution or lazy evaluation.

This means your numThreads is upto the implementation unfortunately.
Not sure if you can handle it in a more granular way.

[Elysia]

The "easy" way is to use a work queue with functors (just use std::function<void()>). Push back functors along with any data it needs to execute. Then each thread locks, pops, unlocks and executes functor. It scales pretty well with few threads.