如何从 std::thread 返回值

Question

I have function that returns me a value. I want to use threads for doSth function and set returning value for variables above, here is an example:

#include <string>
#include <iostream>
#include <thread>

using namespace std;

// func for execution
int doSth(int number)
{
    return number;
}

int main()
{
    // some code ...
    int numberOne; // no value now, but in thread I want to set a value from it
    int numberTwo; // depending on function input value
    thread t1(doSth, 1); // set numberOne = 1;
    thread t2(doSth, 2); // set numberTwo = 2;
    // wait them to execute
    t1.join();
    t2.join();
    // now I should have numberOne = 1; numberTwo = 2
    // some code ...
    return 0;
}

How could I do it?

Answer 1

How to return value from std::thread

Besides std::async shown in other answers, you can use std::packaged_task :

std::packaged_task<int(int)> task{doSth};
std::future<int> result = task.get_future();
task(1);
int numberOne = result.get();

This allows separating creation of the task, and executing it in case that is needed.

Answer 2

Method 1: Using std::async (higher-level wrapper for threads and futures):

#include <thread>
#include <future>
#include <iostream>

int func() { return 1; }

int main(){

    std::future<int> ret = std::async(&func);

    int i = ret.get();

    std::cout<<"I: "<<i<<std::endl;

    return 0;
}

Method 2: Using threads and futures:

#include <thread>
#include <future>
#include <iostream>


void func(std::promise<int> && p) {
    p.set_value(1);
}

int main(){
    std::promise<int> p;
    auto f = p.get_future();
    std::thread t(&func, std::move(p));
    t.join();
    int i = f.get();

    std::cout<<"I: "<<i<<std::endl;

    return 0;
}

Answer 3

My prefered method is encapsulate the call in a specific method returning nothing (and managing error in the same way).

void try_doSth(int number, int* return_value, int* status)
{
  try
  {
    *return_value = doSth(number);
    *status = 0;
   }
  catch(const std::exception& e) { *status = 1; }
  catch(...) { *status = 2; }
}

int r1,r2,s1,s2;
std::thread t1(try_doSth, 1, &r1, &s1);
std::thread t2(try_doSth, 2, &r2, &s2);