CODEWITHSUNDEEP
c++multithreadingfutureblocking
Zacki
Zacki

Reputation: 177

C++ Wait in main thread for future without while(true)

Question

I want to know if it is possible to wait in the main-Thread without any while(1)-loop. I launch a few threads via std::async() and do calculation of numbers on each thread. After i start the threads i want to receive the results back. I do that with a std::future<>.get().

My problem

When i receive the result i call std::future.get(), which blocks the main thread until the calculation on the thread is done. This leads to some slower execution time, if one thread needs considerably more time then the following, where i could do some calculation with the finished results instead and then when the slowest thread is done i maybe have some some further calculation.

Is there a way to idle the main thread until ANY of the threads has finished running? I have thought of a callback function which wakes the main thread up, but i still don't know how to idle the main function without making it unresponsive for i.e. a second and not running a while(true) loop instead.

Current code

#include <iostream>
#include <future>

uint64_t calc_factorial(int start, int number);

int main()
{
    uint64_t n = 1;

    //The user entered number 
    uint64_t number = 0;

    // get the user input
    printf("Enter number (uint64_t): ");
    scanf("%lu", &number);

    std::future<uint64_t> results[4];
    for (int i = 0; i < 4; i++)
    {
        // push to different cores
        results[i] = std::async(std::launch::async, calc_factorial, i + 2, number);
    }

    for (int i = 0; i < 4; i++)
    {
        //retrieve result...I don't want to wait here if one threads needs more time than usual
        n *= results[i].get();
    }
    // print n or the time needed 
    return 0;
}

uint64_t calc_factorial(int start, int number)
{
    uint64_t n = 1;
    for (int i = start; i <= number; i+=4) n *= i;
    return n;
}

I prepared a code snippet which runs fine, I am using the GMP Lib for the big results, but the code runs with uint64_t instead if you enter small numbers.

Note

If you have compiled the GMP library for whatever reason on your PC already you could replace every uint64_t with mpz_class

Upvotes: 1

Views: 1312

Answers (1)

Jerry Coffin
Jerry Coffin

Reputation: 490048

I'd approach this somewhat differently.

Unless I have a fairly specific reason to do otherwise, I tend to approach most multithreaded code the same general way: use a (thread-safe) queue to transmit results. So create an instance of a thread-safe queue, and pass a reference to it to each of the threads that's doing to generate the data. The have whatever thread is going to collect the results grab them from the queue.

This makes it automatic (and trivial) that you create each result as it's produced, rather than getting stuck waiting for one after another has produced results.

Upvotes: 2

Related Questions