est std::file d'attente thread-safe avec les producteurs et plusieurs consommateurs

comment puis-je faire une file d'attente thread-safe? J'ai besoin de push /pop /avant /arrière et clair. est-il quelque chose de semblable dans coup de pouce?

J'ai un producteur et un ou plusieurs consommateurs.

Regarde dans mutex.
Le titre de votre demande s'ils sont thread-safe, mais votre phrase d'ouverture demande comment vous pouvez faire de la sorte. Donc, vous connaissez la réponse à la question est dans le titre déjà.
Double Possible de: C++11 thread-safe file d'attente (stackoverflow.com/questions/15278343/c11-thread-safe-queue)
Ce blog parle: mise en Œuvre d'un Thread-Safe File d'attente à l'aide de Variables de Condition (justsoftwaresolutions.co.royaume-uni/filetage/...). L'auteur du post est le gars qui a écrit en C++ de la Simultanéité dans l'Action.

OriginalL'auteur unikat | 2014-01-23

  1. 2

    Vous devez protéger l'accès à std::queue. Si vous utilisez le boost de le protéger à l'aide de boost::mutex. Maintenant, si vous avez plusieurs lecteurs, et un thread d'écriture regarder boost::shared_lock (pour les lecteurs) et boost::unique_lock(pour l'auteur).

    Toutefois, si vous rencontrez écrivain de threads regarder boost::shared_mutex.

    Je doute que plusieurs lecteurs peuvent lire la file d'attente en temps réel et en toute sécurité. Pour cette question, je crois qu'un lecteur de pop les éléments de la file d'attente. Un pop opération modifie la file d'attente et, par conséquent, doit être titulaire d'un verrou exclusif sur la file d'attente. Dans d'autres contextes, le mot "lecteur" est utilisé pour signifier le code qui effectue aucune modification et regarde simplement les valeurs. Si, dans cette question, les lecteurs sont les appelant coup d'oeil à la place de la pop alors qu'ils satisfont à ces critères et des verrous partagés serait de travailler.
    une solution possible pourrait être une mutable membre drapeau atomique CAS mécanisme qui permet à chaque lecteur de processus de thread un élément unique dans la file d'attente sans éclater, et un nettoyage périodique phase (en vertu d'un verrou exclusif) peut aider à nettoyer les objets traités.

    OriginalL'auteur mindo

  2. 10

    std::queue n'est pas thread-safe si un ou plusieurs threads sont écrit. Et son interface n'est pas propice à un thread-safe mise en œuvre, car il comporte des méthodes telles que pop(), size() et empty() qui doivent être synchronisés à l'extérieur.

    Une approche commune* est de mettre en œuvre un type de file d'attente avec une interface plus simple, et l'utilisation des mécanismes de verrouillage interne pour assurer la synchronisation.

    * Une recherche pour "concurrent de la file d'attente C++" devrait générer beaucoup de résultats. J'ai mis en place un système très simple jouet un ici, où la limitation est à utiliser seulement la norme C++. Voir aussi Anthony Williams livre C++ simultanéité dans l'action, ainsi que son blog.

    Merci pour le lien! Très belle explication.

    OriginalL'auteur juanchopanza

  3. 1

    en boost 1.53 il y a un lockfee file d'attente http://www.boost.org/doc/libs/1_53_0/doc/html/boost/lockfree/queue.html, pas de mutex ou qch comme ça.

    OriginalL'auteur Mike Minaev

  4. 0

    Vous devez le protéger, par exemple, avec un std::mutex, sur chaque opération. Boost serait une alternative si vous n'avez pas de C++11 encore.

    Même ainsi, certaines de synchronisation supplémentaire serait nécessaire (dites que vous voulez vérifier que la file d'attente n'est pas vide avant de les faire éclater. Ce n'est pas atomique, ce qui peut échouer même si les opérations sont synchronisées).

    OriginalL'auteur MSalters