Attendez que tous les threads en C++

Je suis en utilisant le concept de "thread" en C++ et j'ai créer une variable le nombre de thread dans une fonction récursive. Je veux le thread principal à attendre pour tous. Comment puis-je le faire sans WaitForMultipleObjects ?

Les stocker dans un container et attendre pour eux dans une boucle? À l'aide de std::thread il n'y a vraiment pas d'autre moyen. si vous voulez être portable et conformes aux normes.
J'ai essayé de les mettre dans un vecteur, mais, quand je fais la méthode push_back, Visual Studio dit que les fils ne sont pas copiable
vous pouvez pointeurs intelligents au lieu de les fils - e.g std::vector<std::unique_ptr<std::thread>>
vous pouvez poster votre code et l'exacte erreur du compilateur?
Mais les threads sont mobiles. Donc, si vous utilisez une variable pour le thread, vous devez appeler threads.push_back(std::move(my_thread));

OriginalL'auteur Seba92 | 2015-05-18

  1. 20

    Prendre un coup d'oeil à exemple dans cplusplus. Ils stockent les discussions avec push_back() dans le vecteur. À la fin vous avez une boucle avec des jointures.

    std::vector<std::thread> threads;
//create threads
for (int i=1; i<=10; ++i)
    threads.push_back(std::thread(increase_global,1000));
//wait for them to complete
for (auto& th : threads) 
    th.join();
    Pourquoi est-ce une raison pour downvote ?
    Pas mon vote, mais il est généralement moins précis que cppreference.com.
    cplusplus.com a façonné de manière considérable. Downvoting une réponse en se référant à n'est pas constructif. Appel spécificités qui en sont fait, le problème avec cplusplus.com est constructif.
    emplace_back est probablement mieux ici.
    Merci pour les exemples concrets. Alors que je suis d'accord sur certains d'entre eux, je n'ai rien vu d'étrange avec le for boucles. Vous prétendez "Ils ne peuvent même pas écrire un simple numérique for boucle", mais je n'arrive pas à trouver l'erreur flagrante dans ce que vous semblez avoir trouvé.

    OriginalL'auteur M.L.

  2. 3

    Utiliser une variable atomique comme un compteur, augmentation de la variable lors du lancement de la nouvelle thread, le thread de diminuer le compteur une fois que le thread est terminé.

    int main() {
    mutex m;
    condition_variable cv;
    atomic<int> counter = 0;

    //.... in your recursive call
    //increase counter when launching thread.
    counter++;
    thread t([](){
        //do whatever
        lock_guard<mutex> lk(m);
        counter--;
        cv.notify_all();
    });
    t.detach(); //no need to join anymore.
    //.... end recursive call

    unique_lock<mutex> lock(m);
    cv.wait(lock, [](){ return counter == 0; });
}
    Et d'ajouter les frais généraux de bureaux de vote (ce qui est fait par certains des condition_variable.wait() implémentations) à la solution?
    la variable de condition de blocage est pas d'interrogation, à la jointure de thread bloque également.

    OriginalL'auteur Min Lin

  3. 2

    Je ne connais pas les détails de votre situation, mais ce type d'approche peut être utile pour vous:

    using thread_vec = std::vector<std::thread>;

void batch_process(int n)
{
    static std::mutex mtx;
    std::lock_guard<std::mutex> lock(mtx);
    std::cout << "process: " << n << '\n';
}

void recursive(thread_vec& tv, int n)
{
    //do some stuff
    tv.emplace_back(batch_process, n);

    if(n > 0)
        recursive(tv, n - 1);
}

int main(int, char* argv[])
{
    thread_vec tv;

    recursive(tv, 3);

    for(auto&& t: tv)
        t.join();
}

    De sortie:

    process: 1
process: 0
process: 2
process: 3

    OriginalL'auteur Galik

  4. 1

    Vous pouvez également utiliser boost thread_group. Il fonctionne uniquement avec le boost filets, mais ils ont presque une interface identique à std::thread (boost fils étaient à la base de threads dans la bibliothèque standard de C++11), et une fois que vous avez ajouté tous vos fils à la thread_group, il vous suffit d'appeler join_all sur le groupe. Vous pourriez également mettre en œuvre un thread_group classe de votre choix, de travailler avec std::thread, qui serait essentiellement le faire ce qui a déjà été suggéré, avec un vecteur de fil d'objets ou de pointeurs, et il attend d'eux dans une boucle.

    OriginalL'auteur Elkvis