Линейный потокобезопасный std :: cerr для C++

Question

Самый простой способ создать мой собственный std::cerr так, чтобы он был поточно-потоковым.

Я предпочитаю код для этого.

Что мне нужно, так что a line of output (завершено с std :: endl), сгенерированным одним потоком, остается as a line of output, когда я действительно вижу его на консоли. (И не смешивается с выходом другой другой резьбы)

РЕШЕНИЕ: std::cerr МНОГО медленнее, чем cstdio. Я предпочитаю использовать fprintf(stderr, "The message") внутри конструктора класса «CriticalSectionLocker», который использует безопасный для потолка замок, и дедуктор отпускает его.

Answer 1

Это:

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

работает на большинстве компиляторов для общего случая myerr("ERR: " << message << number).

Answer 2

У вас нет. Нет ничего о std::cerr (и ни один другой общий объект на всем языке), который может знать, какой поток выполняет конкретный вызов << operator, чтобы предотвратить чередование.

Лучшее, что вы можете сделать, это создать кучу нит конкретных объектов регистратора, что каждый накапливают данные до новой строки не будет достигнуто, то получить блокировку, которая защищает cerr так, чтобы написать целую строку сразу cerr удерживая замок.

Answer 3

Улучшение (что совсем не похоже на комментарий) на подход в комментарии пользователя unixman.

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

который может быть использован как

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

если ErrCriticalSectionLocker тщательно выполнены.

Но я лично предпочел бы предложение Кена.

Answer 4

Вот решение, основанное на потоке, основанное на логике, которое я приготовил в какой-то момент. Он использует повышающий мьютекс для обеспечения безопасности потоков. Это немного сложнее, чем это необходимо, потому что вы можете подключить выходные политики (она должна идти в файл, STDERR, или где-нибудь еще?):

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 

Использование выглядит следующим образом:

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

сведению отсутствие '\n' и std::endl, так как это подразумевается. Содержимое буферизуется, а затем атомарно выводится с использованием политики, указанной в шаблоне. Эта реализация также добавляет строку с меткой времени, поскольку она предназначена для ведения журнала. Политика no_output строго необязательна, это то, что я использую, когда хочу отключить ведение журнала.

Answer 5

Почему бы не просто создать класс блокировки и использовать его там, где вы хотите сделать потокобезопасный ввод-вывод?

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(); 

Тогда вы положили любой IO вы хотите в блоке:

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

становится:

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