cout<< avec plusieurs threads

Bonjour,
j'ai fait un programme où plusieurs threads recherchent simultanément la solution d'un problème d'optimatisation , et proposent la leur quand ils en ont une.
Il arrive parfois que deux threads trouvent en même temps, et là les malins utilisent en même temps l'objet "cout" ce qui donne sur la console un drôle de charabia.
Comment m'y prendre pour faire un lock sur iostream ?
Merci

Ce que j'ai fait il y a fort longtemps:
- un streambuf frontal qui contient un streambuf par thread (en interne, il peut contenir un buffer de chars sous forme de vecteur p.ex.), et qui contient une référence vers le streambuf qui appartenait initialement au flux sortant final (genre std::cout, ou même un fichier, ça ne change rien)
- on change le streambuf de std::cout (ou du fichier) par celui de premier niveau
- quand quelque chose arrive sur le frontal, c'est dispatché au sous-streambuf du thread courant
- quand un flush arrive, il est dispatché au streambuf du thread courant donc, et cela a pour effet de dispatcher ce qui est couramment en cache dans le streambuf du thread vers le streambuf de destination, avec flush en plus.

Ca, c'est la solution canonique type, 100% flux. Ce n'est pas forcément la plus pertinente aujourd'hui.

L'autre solution est d'utiliser une lib dédié et fait ça, et bien plus, comme spdlog p.ex.

Autre possibilité: avoir un thread de collecte les résultats (avec queue de messages), et c'est ce seul thread qui se charge des logs & cie. C'est probablement le désign le plus commun aujourd'hui j'imagine.

J'allais aussi dire "utiliser une bibliothèque de logging" et j'allais aussi proposer spdlog. Je me vois obliger de plusser :plusser:

@Legro: L'exemple de base devrait résoudre ton problème : https://github.com/gabime/spdlog#usage-samples

Merci !

Citation:

---

Autre possibilité: avoir un thread de collecte les résultats (avec queue de messages), et c'est ce seul thread qui se charge des logs & cie. C'est probablement le désign le plus commun aujourd'hui j'imagine.

---

Ah ben oui tout bête et tout simple. Je pense que dans mon cas où il ne s'agit que de quelques affichages ci et là, cette solution suffira largement.

spdlog est excessivement simple à mettre en place. Bien plus que de dédier un thread aux logs.

Legro un unique operateur << est garanti thread safe, donc ce que je fait moi c'est :

Code:

---

1 2 3 4

std::stringstream msg; msg << "Error:" << Err_num << ", " << ErrorString( Err_num ) << "\n"; std::cout << msg.str();

---

Citation:

---

I'm assuming that what you're really trying to do it stop std::cout from mixing string when concatenating with the operator<< multiple time per string, across multiple threads.

---

source : https://stackoverflow.com/questions/...ut-thread-safe

Citation:

---

Envoyé par Katian

Legro un unique operateur << est garanti thread safe, donc ce que je fait moi c'est :

Code:

---

1 2 3 4

std::stringstream msg; msg << "Error:" << Err_num << ", " << ErrorString( Err_num ) << "\n"; std::cout << msg.str();

---

---

Ce n'est pas garanti thread safe dans ce sens-là.

Dans le cas de std::cout, par défaut, on a bien la garantie qu'un appel à << n'engendre pas de data race, mais pas de garantie que l'opération soit atomique, donc il peut y avoir des intercalations de caractères.

Extrait de la doc de std::cout :
« Unless sync_with_stdio(false) has been issued, it is safe to concurrently access these objects from multiple threads for both formatted and unformatted output. »

Mais voici ce que dit la doc de std::std::ios_base::sync_with_stdio :
« In addition, synchronized C++ streams are guaranteed to be thread-safe (individual characters output from multiple threads may interleave, but no data races occur) ».

merci Pyramidev, je pensais avoir trouvé une solution simple, désolé

Citation:

---

A mutex-protected wrapper for cout is probably the best way to go.

---

Comme solution "simple" à venir il y a std::osyncstream de c++20. Mais actuellement mieux vaut utiliser une bibliothèque externe.

merci !

et ce code pourrais faire l'affaire ?

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

static std::mutex mtx_cout;   // Asynchronous output struct acout { std::unique_lock<std::mutex> lk; acout() : lk(std::unique_lock<std::mutex>(mtx_cout)) {   }   template<typename T> acout& operator<<(const T& _t) { std::cout << _t; return *this; } };

---