1
votes

Comment renvoyer la valeur de std :: thread

J'ai une fonction qui me renvoie une valeur. Je souhaite utiliser des threads pour la fonction doSth et définir la valeur de retour des variables ci-dessus, voici un exemple:

#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;
}

Comment pourrais-je le faire?

c++ multithreading

3 commentaires

Ce type de problème est mieux résolu avec std :: async < / a> à la place. C'est fondamentalement un fil qui peut revenir.

@ FrançoisAndrieux pouvez-vous me montrer comment pourrais-je faire ce genre de choses en utilisant std :: async , s'il vous plaît?

Mon commentaire précédent contient un lien vers la documentation de la fonction. Il contient des exemples.

3 Réponses :

0
votes

Comment renvoyer la valeur de std :: thread

Outre std :: async indiqué dans d'autres réponses, vous pouvez utiliser std::packaged_task:
std::packaged_task<int(int)> task{doSth};
std::future<int> result = task.get_future();
task(1);
int numberOne = result.get();
Cela permet de séparer la création de la tâche et de l'exécuter au cas où cela serait nécessaire.

0 commentaires

0
votes

Méthode 1: Utilisation de std :: async (wrapper de niveau supérieur pour les threads et les futurs):

#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;
}

Méthode 2: Utilisation des threads et des futurs:

#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;
}

1 commentaires

Cela ne répond pas à la question, mais ce code n'a pas besoin du truc supplémentaire que fait std :: endl . '\ n' termine une ligne.

0
votes

Ma méthode préférée est d'encapsuler l'appel dans une méthode spécifique ne renvoyant rien (et gérant l'erreur de la même manière).

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);

0 commentaires