Comment faire facilement des std::cout "thread-safe"?

Je suppose que vous pourriez mettre en place votre propre classe qui encapsule cout et associe un mutex. Le operator << de cette nouvelle classe serait de faire trois choses:

1. créer un verrou pour le mutex, éventuellement bloquer les autres threads
2. faire la sortie, c'est à dire faire de l'opérateur << pour le flux encapsulé et l'argument passé
3. construire une instance d'un différents classe, en passant la serrure pour que

Cette classe différente serait de garder la serrure et délégué de l'opérateur << le flux encapsulé. Le destructeur de cette seconde classe finirait par détruire la serrure et la libération du mutex.

De sorte que toute sortie vous écrivez comme une seule instruction, c'est à dire qu'une seule séquence de << invocations, sera imprimé automatiquement tant que la totalité de votre sortie passe à travers cet objet avec la même mutex.

Appelons les deux classes synchronized_ostream et locked_ostream. Si sync_cout est une instance de synchronized_ostream qui enveloppe std::cout, puis la séquence

sync_cout << "Hello, " << name << "!" << std::endl;

entraînerait les actions suivantes:

1. synchronized_ostream::operator<< serait d'acquérir le verrou
2. synchronized_ostream::operator<< serait délégué à l'impression de "Bonjour", à cout
3. operator<<(std::ostream&, const char*) devrait afficher "Bonjour, "
4. synchronized_ostream::operator<< serait de construire un locked_ostream et passer le verrou pour que
5. locked_ostream::operator<< serait délégué à l'impression de name à cout
6. operator<<(std::ostream&, std::string) serait d'imprimer le nom
7. La même délégation à cout se passe pour le point d'exclamation et la fin manipulateur
8. La locked_ostream temporaire obtient détruits, le verrou est libéré

OriginalL'auteur MvG

J'aime vraiment le truc de Nicolás donné dans cette question de la création d'un objet temporaire 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{} << "my_val=" << val << std::endl;

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

OriginalL'auteur Conchylicultor

Rapide pour le débogage c++11 applications et éviter entrelacés de sortie je viens de d'écrire de petites fonctions comme celles-ci:

...
#include <mutex>
...
mutex m_screen;
...
void msg(char const * const message);
...
void msg(char const * const message)
{
  m_screen.lock();
  cout << message << endl;
  m_screen.unlock();
}

- Je utiliser ces types de fonctions pour les sorties et si les valeurs numériques sont nécessaires, je viens de l'utiliser quelque chose comme ceci:

void msgInt(char const * const message, int const &value);
...
void msgInt(char const * const message, int const &value)
{
  m_screen.lock();
  cout << message << " = " << value << endl;
  m_screen.unlock();
}

C'est facile et fonctionne très bien pour moi, mais je ne sais pas vraiment si c'est techniquement correcte. Donc, je serais heureux d'entendre vos opinions.

Bien, je n'ai pas lu ceci:

Je ne veux pas de recherche pour chaque occurrence de std::cout et ajouter une ligne de code de verrouillage.

Je suis désolé. Cependant j'espère que cela aide quelqu'un.

OriginalL'auteur Germinx

Je sais que c'est une vieille question, mais il m'a beaucoup aidé avec mon problème. J'ai créé une classe utilitaire basé sur ce post, les réponses et je tiens à partager mon résultat.

Vu qu'on utilise C++11 ou les dernières versions C++, cette classe fournit print et println fonctions de composer des chaînes avant d'appeler le flux de sortie standard et d'éviter les problèmes de concurrence d'accès. Ce sont variadic fonctions qui utilisent des modèles pour imprimer différents types de données.

Vous pouvez vérifier son utilisation dans un producteur-consommateur problème sur mon github: https://github.com/eloiluiz/threadsBar

Donc, voici mon code:

class Console {
private:
    Console() = default;

    inline static void innerPrint(std::ostream &stream) {}

    template<typename Head, typename... Tail>
    inline static void innerPrint(std::ostream &stream, Head const head, Tail const ...tail) {
        stream << head;
        innerPrint(stream, tail...);
    }

public:
    template<typename Head, typename... Tail>
    inline static void print(Head const head, Tail const ...tail) {
        //Create a stream buffer
        std::stringbuf buffer;
        std::ostream stream(&buffer);
        //Feed input parameters to the stream object
        innerPrint(stream, head, tail...);
        //Print into console and flush
        std::cout << buffer.str();
    }

    template<typename Head, typename... Tail>
    inline static void println(Head const head, Tail const ...tail) {
        print(head, tail..., "\n");
    }
};

OriginalL'auteur eloiluiz

En plus de la synchronisation de cette solution fournit des informations sur le fil à partir de laquelle le journal a été écrit.

AVERTISSEMENT: C'est très naïf façon de synchroniser les journaux, mais il peut aussi être applicable pour certains petits cas d'utilisation à des fins de débogage.

thread_local int thread_id = -1;
std::atomic<int> thread_count;
struct CurrentThread {
static void init() {
if (thread_id == -1) {
thread_id = thread_count++;
}
}
friend std::ostream &operator<<(std::ostream &os, const CurrentThread &t) {
os << "[Thread-" << thread_id << "] - ";
return os;
}
};
CurrentThread current_thread;
std::mutex io_lock;
#ifdef DEBUG
#define LOG(x) {CurrentThread::init(); std::unique_lock<std::mutex> lk(io_lock); cout << current_thread; x << endl;}
#else
#define LOG(x)
#endif

Cela peut être utilisé comme cela.

LOG(cout << "Waiting for some event");

Et il vous donnera la sortie du journal

[Thread-1] - Entering critical section 
[Thread-2] - Waiting on mutex
[Thread-1] - Leaving critical section, unlocking the mutex

OriginalL'auteur samvel1024