en utilisant std::cout dans plusieurs threads

J'écris un programme simple pour les tests de Threads en c++11, mais std::cout ne fonctionne pas comme prévu.

class Printer
{
public:
    void exec()
    {
        mutex m;
        m.lock();
        cout<<"Hello  "<<this_thread::get_id()<<endl;
        chrono::milliseconds duration( 100 );
        this_thread::sleep_for( duration );
        m.unlock();

    }
};

int main()
{
    Printer printer;

    thread firstThread([&printer](){
        while(1)
            printer.exec();

    });
    thread secondThread([&printer](){
        while(1)
            printer.exec();
    });

    firstThread.join();
    secondThread.join();     
}

certains des résultats :

Hello 11376
Hello 16076
Hello 16076
Hello Hello 11376
16076
Hello 11376
,....

J'ai utilisé mutex pour le verrouillage de fils donc je ne peux pas comprendre pourquoi deux threads s'exécutent std::cout en même temps.
Il coutures très weired pour moi.Quelqu'un peut-il expliquer ce qui se passe!?!

Une fois que vous mettre en œuvre la solution fournie dans la réponse, vous devez également déplacer à l'aide de lock_guards plutôt que manuel de verrouillage/déverrouillage des appels. Et ne pas la peine de rinçage (par exemple, avec endl); il suffit d'utiliser le caractère '\n'.

OriginalL'auteur Omid | 2013-08-16

  1. 24

    Les filets à l'aide de différents mutex instances comme le mutex est une variable locale dans la exec() fonction de verrouillage de la mutex est inutile que chaque thread va être verrouillage de ses propres mutex résultant en l'absence de synchronisation entre les threads. La même mutex instance doit être utilisé par les threads pour obtenir une synchronisation.

    À corriger dans la publication de code, de créer la mutex une variable membre. Toutefois, si un autre Printer objet a été créé alors il n'y aurait pas de synchronisation entre les threads utilisés dans les différents Printer instances. Dans ce cas, le mutex aurait besoin d'être un static variable de membre pour assurer la synchronisation:

    class Printer
{
public:
    //...
private:
    static std::mutex mtx_;
};

std::mutex Printer::mtx_;

    Pour assurer une mutex est toujours publié, peu importe si une fonction se termine normalement ou par l'intermédiaire d'une exception, l'utilisation std:lock_guard:

    std::lock_guard<std::mutex> lock(m); //'m' locked, and will be
                                     //unlocked when 'lock' is destroyed.
std::cout<< "Hello  " << std::this_thread::get_id() << std::endl;
std::chrono::milliseconds duration( 100 );
std::this_thread::sleep_for( duration );
    Solution est de déclarer mutex avec static durée de stockage. ... ou que.
    ou un membre de la variable comme les filets à l'aide de la même Printer instance.
    Je préfère static dans ce cas, correspondre à la portée de std::cout. De cette façon, il va continuer à travailler lors de l'entretien programmeur en bas de la ligne crée un autre Printer dans une autre fonction.
    unique_lock serait mieux dans ce cas, car permet de déverrouiller-ing juste après l'envoi de données vers le cout et avant d'entrer dans le sommeil (il n'est pas bon pour la tenue de l'mutex pendant le sommeil).

    OriginalL'auteur hmjd

  2. 13

    Accepté la réponse est correcte. Toutefois, il est bon de séparer les préoccupations:

    1. Vous avez besoin d'un moyen d'imprimer à std::cout dans un thread de manière sûre.
    2. Vous avez besoin pour créer des objets/foncteurs/fonctions à exécuter dans les fils et les lancer.

    Ici est un utilitaire j'utilise juste se concentre sur la collecte des arguments à std::cout et streaming sous un static std::mutex:

    #include <iostream>
#include <mutex>

std::ostream&
print_one(std::ostream& os)
{
    return os;
}

template <class A0, class ...Args>
std::ostream&
print_one(std::ostream& os, const A0& a0, const Args& ...args)
{
    os << a0;
    return print_one(os, args...);
}

template <class ...Args>
std::ostream&
print(std::ostream& os, const Args& ...args)
{
    return print_one(os, args...);
}

std::mutex&
get_cout_mutex()
{
    static std::mutex m;
    return m;
}

template <class ...Args>
std::ostream&
print(const Args& ...args)
{
    std::lock_guard<std::mutex> _(get_cout_mutex());
    return print(std::cout, args...);
}

    Ce code peut être réutilisé pour les cours d'eau autres que std::cout, mais le dessus est spécialisée à la juste cible std::cout. Avec cela, votre Printer::exec() peut maintenant être considérablement simplifiée:

    void exec()
{
    print("Hello ", std::this_thread::get_id(), '\n');
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
}

    Maintenant, non seulement votre Printer utilisation cout dans un thread-safe manière, et a été simplifiée (par exemple, n'a pas besoin de maintenir sa propre mutex pour cout), mais tous les autres types et les fonctions peuvent également utiliser cout et tous interagissent ensemble en toute sécurité. Le print fonction elle-même entretient désormais le mutex, et ce fait est encapsulé à l'écart de tous les prints clients.

    l'impression est une fonction de modèle. Je pense que vous pouvez vous retrouver avec plus d'un mutex.
    Excellent site d'observation! Et il n'a fallu que 3 ans pour que quelqu'un remarque! 🙂 Fixe. Merci.

    OriginalL'auteur Howard Hinnant

  3. 4

    Je partage l'astuce est de Nicolás donné dans cette question que je trouve plus élégant que Howard Hinnant mise en œuvre. L'idée est de créer un temporaire ostringstream objet et de mettre le code de protection sur le destructeur.

    /** Thread safe cout class
  * Exemple of use:
  *    PrintThread{} << "Hello world!" << std::endl;
  */
class PrintThread: public std::ostringstream
{
public:
    PrintThread() = default;

    ~PrintThread()
    {
        std::lock_guard<std::mutex> guard(_mutexPrint);
        std::cout << this->str();
    }

private:
    static std::mutex _mutexPrint;
};

std::mutex PrintThread::_mutexPrint{};

    Vous pouvez ensuite l'utiliser comme un régulier std::cout, à partir de n'importe quel thread:

    PrintThread{} << "val = " << 33 << std::endl;

    L'objet de recueillir des données de manière régulière std::ostringstream. Dès le coma est atteint, l'objet est détruit et rincer tous les renseignements recueillis.

    Voici un léger le raffinement de cette réponse à un cas de test.

    OriginalL'auteur Conchylicultor

  4. 1

    Vous pouvez envisager un mondial std::mutex cout_mutex; (quelque part dans vos espaces de noms), qui est utilisé pour protégé std::cout de sortie. Assurez-vous d'utiliser std::lock<std::mutex> (donc vous ne pouvez pas oublier de déverrouiller le mutex et d'exception de sécurité).

    OriginalL'auteur Walter