C++的基於線程的線程安全的std :: cerr

Question

創建我自己的std::cerr以便它是逐行線程安全的最簡單方法是什麼？

我最好尋找代碼來做到這一點。

我需要的是當我在控制檯上看到它時，由一個線程生成的a line of output（以std :: endl結尾）保持as a line of output。 （並沒有與其他線程的輸出混合）

解決方案：std::cerr比cstdio慢很多。我更喜歡在CriticalSectionLocker類中使用fprintf(stderr, "The message") whos的構造函數獲得線程安全鎖，並且desturctor釋放它。

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 

如果ErrCriticalSectionLocker是認真落實其中可用於像

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

。

但是，我個人更喜歡肯的建議。

Answer 4

這是一個基於線程安全行的日誌記錄解決方案，我在某個時候製作了。它使用boost mutex來保證線程安全。這是略超過必要的複雜，因爲你可以在輸出政策塞（它應該去的文件，標準錯誤，或別的地方？）：

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

爲什麼不只是創建一個鎖定類，並在任何想要執行線程安全IO的地方使用它？

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; 
}