C++ de la communication entre les threads

J'ai un couple de classes que chaque ouvrir un autre programme dans différents threads et n'/contenir des informations sur l'aide CreateProcess (si il y a une C++ orienté de façon à ce faire laissez-moi savoir, j'ai regardé).

Certaines classes sont dépendants l'un de l'autres programmes en cours d'exécution. ie B doit s'arrêter si Un arrêté. J'ai fait ce code il y a un moment et ma solution était d'avoir une classe avec des fonctions statiques d'exécuter les différents programmes et membre statique des variables qui tiennent leur "état". J'ai été également à l'aide de CreateThread.

En regardant en arrière, cette méthode a semblé... fragile et maladroit à la recherche.
Je n'ai aucune idée si l'utilisation d'une telle "classe statique" est une bonne pratique ou pas (en particulier rappelant comment maladroit de l'initialisation de l'état des variables de membre). J'aimerais peut-être faire de chaque classe contient sa propre fonction d'exécution. Cependant, la question que j'envisage est de savoir comment laisser de classe B savoir si Un a maladroitement arrêté. Ils avaient encore besoin de savoir pour être au courant de chaque de l'autre état. Remarque que je voudrais utiliser std::thread dans ce retravailler et que j'ai peu ou pas d'expérience avec le multithreading. Merci pour toute aide.

OriginalL'auteur 2c2c | 2013-12-15

  1. 8

    Bien, dans un environnement multi-processus de demande, vous seriez à l'aide de tuyaux/fichiers à transmettre des informations à partir d'un processus à un autre (ou peut-être même la valeur de retour d'un processus enfant). Ainsi pourrait également essayer de mémoire partagée, même si elle peut être un peu difficile (regardez dans Boost.Interprocessus si vous le souhaitez).

    Dans une application multi-thread en gros, vous avez les mêmes options disponibles:

    • vous pouvez utiliser la mémoire partagée (à condition de synchroniser l'accès)
    • vous pouvez utiliser les files d'attente pour passer des informations d'un thread à l'autre (comme avec des tuyaux)

    alors, vraiment, les deux sont très similaires.

    Suivantes Tony Hoare du précepte, vous devez généralement part, par la communication, et de ne pas communiquer en partageant, ce qui signifie en privilégiant les files d'attente/tubes à mémoire partagée; cependant, pour juste un indicateur booléen, la mémoire partagée peut s'avérer plus facile à mettre en place:

    void do_a(std::atomic_bool& done) {
     //do things
     done = true;
}

int main() {
    std::atomic_bool done = false;

    auto a = std::async(do_a, done);

    auto b = std::async([](std::atomic_bool& done) {
        while (not done) {
            std::cout << "still not done" << std::endl;
            sleep(1);
        }
    });

    //other stuff in parallel.
}

    Et bien sûr, vous pouvez même insérer cet indicateur dans un std::shared_ptr afin d'éviter le risque de pendre des références.

    malheureusement, ce n'est même pas compiler. J'utilise VS11 et la sensation de quelque chose qui n'est pas implémentée concernant atomics.
    eh bien, si vous n'avez pas accès à atomics, vous pouvez revenir en arrière pour les mutex. En fait, si vous voulez attendre (aucune action) jusqu'à ce que quelque chose est fait, un mutex + variable d'état de la conception est moins gourmand en ressource.
    Devrais-je passer un mutex autour de chacune des classes? Je ne suis pas sûr de ce que serait le sens comme un moyen de faire de chaque classe ont accès mondial. Encore une fois je suis un peu paumé dans ce domaine, désolé )
    Ce serait génial si vous pouviez exemple avec les files d'attente comme vous l'avez suggéré...
    Malheureusement, contrairement à d'autres langues, il n'existe aucune norme multi-thread de la file d'attente en C++ (et autant que je sache, aucune n'est venue en C++17). Si le Boost est une option, je vous conseille de vérifier cette page, qui montrent des cas de lock-free et attendre sans piles/files d'attente.

    OriginalL'auteur Matthieu M.