C++ std::thread termination before join

Question

I am writing a C++ code to do a task on different threads and await the result to return to the main function.

Each thread can take different timing and might result in a correct or incorrect result.

I start the threads as follows:

std::thread p1(&process1, (void*)&p1Data);
std::thread p2(&process2, (void*)&p2Data);
std::thread p3(&process3, (void*)&p3Data);
.
.
.

(Multiple threads are created this way).

The Process Functions can be summarized like this:

\\ThreadData is a structure that contains all the data for the thread
void process1(void *data)
{
    ThreadData * tData = (ThreadData*) data;
    ResultObject * result = data->result;
    .
    .
    .
    \\Process to calculate Result using data
}

in main after I launch those threads I join them to await final results and then check the correct one.

p1.join();
p2.join();
.
.
.

p1result = p1Data.result;
p2result = p2Data.result;
.
.
.
.
.
.

if (p1result)
{
    return p1Data;
}

if (p2result)
{
    return p2Data;
}

But the issue is (for sake of simplicity I will consider that p1 is the fastest thread) if p1 is done with correct result, I am still forced to wait the join for all the other threads to get my final result while p1 that was done first can contain the correct one and I can just terminate on it.

How can I check on each thread when it is done if the result is ok so that I can terminate the remaining threads without the need on waiting on them to be done (ie if p2 finished before p1 and the result of p2 is acceptable, i can return p2Data and just terminate all the remaining threads without)

Why those C-style casts to void pointer? Is that really your code? — Ulrich Eckhardt, Nov 24 '21 at 08:45
this looks like you only made half of the transition from pthreads to `std::thread`. `void*` is not necessary. If you want to pass `ThreadData` then just pass `ThreadData` — 463035818_is_not_an_ai, Nov 24 '21 at 08:47
https://stackoverflow.com/questions/19225372/waiting-for-multiple-futures. Also, start the computations using `std::async`. BTW: Concerning your question title, a thread *must* terminate before you can finish the join, so this doesn't make clear what you want. — Ulrich Eckhardt, Nov 24 '21 at 08:52
UlrichEckhardt as 463035818_is_not_a_number stated i did half the transition from pthread. Quimby yes i only need 1 correct result from whatever thread i get first — EYakoumi, Nov 24 '21 at 08:55

Quimby · Answer 1 · 2021-11-24T09:31:48.540

Unfortunately there is no std::shared_promise that would have atomic set_if_still_empty() and is_empty() methods. Furthermore threads cannot be terminated from the outside (that's a good thing), C++20 solves it with std::jthread and its stop tokens, feel free to use that. I will use just std::atomic_bool flag. In both cases the thread itself must monitor the token and terminate itself if requested.

My solution uses std::promise to store the result, it will throw if the result has been set already and its setter is atomic, so no extra lock needed.

#include <future>
#include <thread>
#include <atomic>

using result_t=int;

void worker(std::promise<result_t>& promise,std::atomic_bool& stop_requested){
    //periodically check flag
    while(!stop_requested){
        // do work
        
        // if result
        result_t result=1;
        try{
            promise.set_value(result);
            // Terminate other threads soon, including us.
            stop_requested=true;
            return; // Not need if there is no work after `try` statement.
        }
        catch(const std::future_error&)//Already set
        {
            return;

        }     
    }
}

int main() {

    std::promise<result_t> promise;
    std::atomic_bool stop_token= false;

    std::thread w1(worker,std::ref(promise),std::ref(stop_token));

    auto future = promise.get_future();
   
    result_t result = future.get();
    // All threads should terminated soon after they check the token.
    //stop_token=true;// Is not necessary because it is set by the winning thread.

    w1.join();
    
}

Alternatively, std::optional<result_t> + lock could be used too. But you would have to lock periodically to check whether the result is there and the thread should exit.

score -2 · Answer 2 · answered Nov 24 '21 at 09:17

-2

You need to implement a synchronization mechanism within the threads themselves,using a mutex.

When a thread terminate, it can tell the other threads they can terminate early (using std::terminate within the thread) by just locking the mutex, writing the results and releasing the mutex. Each thread then have to look up if they can terminate early at regular intervals.

See: How do I terminate a thread in C++11?

answered Nov 24 '21 at 09:17

Laurent Jospin

604
5
9

1

By default, calling `std::terminate()` will forcibly exit the calling process. You DON'T want to do that in this case, And a mutex is not the way to signal other threads to terminate early. Consider using an atomic bool, a condition_variable, or a signalable event instead. – Remy Lebeau Nov 24 '21 at 09:41

C++ std::thread termination before join

2 Answers2