Un thread-safe thread-safe std :: cerr pour C++

Question

Quelle est la manière la plus facile de créer mon propre std::cerr afin qu'il soit threadsafe ligne par ligne.

Je cherche de préférence le code pour le faire. Ce dont j'ai besoin est que a line of output (terminé avec std :: endl) généré par un thread reste as a line of output quand je le vois réellement sur ma console. (Et n'est pas mélangé avec la sortie d'un autre thread)

SOLUTION: std::cerr est BEAUCOUP plus lent que cstdio. Je préfère utiliser fprintf(stderr, "The message") à l'intérieur d'une classe CriticalSectionLocker dont le constructeur acquiert un verrou thread-safe et que le desturctor le libère.

Answer 1

Ce:

#define myerr(e) {CiriticalSectionLocker crit; std::cerr << e << std::endl;} 

fonctionne sur la plupart des compilateurs pour le cas commun de myerr("ERR: " << message << number).

Answer 2

Ce n'est pas le cas. Il n'y a rien sur std::cerr (ni aucun autre objet partagé dans la langue entière) qui peut savoir quel thread fait un appel particulier au << operator pour empêcher l'entrelacement.

Le mieux que vous pouvez faire est de créer un tas d'objets de l'enregistreur spécifiques au thread que chaque accumuler des données jusqu'à ce qu'un saut de ligne est atteinte, un verrou qui protège cerr de manière à écrire une ligne entière à la fois à cerr tout en maintenant la fermer à clé.

Answer 3

Une amélioration (qui ne rentre pas vraiment dans un commentaire) sur l'approche dans le commentaire d'unixman.

#define LOCKED_ERR \ 
    if(ErrCriticalSectionLocker crit = ErrCriticalSectionLocker()); \ 
    else std::cerr 

qui peut être utilisé comme

LOCKED_ERR << "ERR: " << message << endl; 

si ErrCriticalSectionLocker est mis en œuvre avec soin. Mais, personnellement, je préfère la suggestion de Ken.

Answer 4

Voici une solution de journalisation basée sur les threads sûrs que j'ai cuits à un moment donné. Il utilise boost mutex pour la sécurité des threads. Il est un peu plus compliqué que nécessaire parce que vous pouvez brancher dans les politiques de sortie (si il aller à un fichier, stderr, ou ailleurs?):

logger.h:

#ifndef LOGGER_20080723_H_ 
#define LOGGER_20080723_H_ 

#include <boost/thread/mutex.hpp> 
#include <iostream> 
#include <cassert> 
#include <sstream> 
#include <ctime> 
#include <ostream> 

namespace logger { 
    namespace detail { 

     template<class Ch, class Tr, class A> 
     class no_output { 
     private: 
      struct null_buffer { 
       template<class T> 
       null_buffer &operator<<(const T &) { 
        return *this; 
       } 
      }; 
     public: 
      typedef null_buffer stream_buffer; 

     public: 
      void operator()(const stream_buffer &) { 
      } 
     }; 

     template<class Ch, class Tr, class A> 
     class output_to_clog { 
     public: 
      typedef std::basic_ostringstream<Ch, Tr, A> stream_buffer; 
     public: 
      void operator()(const stream_buffer &s) { 
       static boost::mutex mutex; 
       boost::mutex::scoped_lock lock(mutex); 
       std::clog << now() << ": " << s.str() << std::endl; 
      } 

     private: 
      static std::string now() { 
       char buf[64]; 
       const time_t tm = time(0); 
       strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", localtime(&tm)); 
       return buf; 
      } 

     }; 

     template<template <class Ch, class Tr, class A> class OutputPolicy, class Ch = char, class Tr = std::char_traits<Ch>, class A = std::allocator<Ch> > 
     class logger { 
      typedef OutputPolicy<Ch, Tr, A> output_policy; 
     public: 
      ~logger() { 
       output_policy()(m_SS); 
      } 
     public: 
      template<class T> 
      logger &operator<<(const T &x) { 
       m_SS << x; 
       return *this; 
      } 
     private: 
      typename output_policy::stream_buffer m_SS; 
     }; 
    } 

    class log : public detail::logger<detail::output_to_clog> { 
    }; 
} 

#endif 

Utilisation ressemble à ceci:

logger::log() << "this is a test" << 1234 << "testing"; 

note l'absence d'un '\n' et std::endl puisqu'il est implicite. Les contenus sont mis en mémoire tampon puis sortis de façon atomique à l'aide de la stratégie spécifiée par le modèle. Cette implémentation ajoute également un horodatage à la ligne, car elle sert à la consignation. La politique no_output est strictement facultative, c'est ce que j'utilise lorsque je veux désactiver la journalisation.

Answer 5

Pourquoi ne pas simplement créer une classe de verrouillage et l'utiliser là où vous voulez faire des E/S sécurisées?

class LockIO 
{ 
    static pthread_mutex_t *mutex; 
public: 
    LockIO() { pthread_mutex_lock(mutex); } 
    ~LockIO() { pthread_mutex_unlock(mutex); } 
}; 

static pthread_mutex_t* getMutex() 
{ 
    pthread_mutex_t *mutex = new pthread_mutex_t; 
    pthread_mutex_init(mutex, NULL); 
    return mutex; 
} 
pthread_mutex_t* LockIO::mutex = getMutex(); 

Ensuite, vous mettez une IO que vous voulez dans un bloc:

std::cout <<"X is " <<x <<std::endl; 

devient:

{ 
    LockIO lock; 
    std::cout <<"X is " <<x <<std::endl; 
}