1

我目前正在创建一个应该用于记录目的的类。

但是这里有一个问题，它不支持线程同步。当我一个一个线程运行时没有问题。但是当我一次运行两个或多个线程时出现问题。

我面临的问题是：“如果我创建两个线程来创建两个单独的日志，但是两个线程正在冲突并将其日志消息写入两个文件”。

如果有人发现问题，请帮我解决。

BoostLogger.h：

#pragma once
......
///////////////////////////////////////
//Defining Macros
///////////////////////////////////////
#define AddCommonAttr()         logging::add_common_attributes()
#define GetLoggingCore()        logging::core::get()
#define LoggingSeverity         logging::trivial::severity
#define AddFileLog              logging::add_file_log
#define ThreadValueType         logging::attributes::current_thread_id::value_type
#define Record                  logging::record
#define Extract                 logging::extract

#define ExprStream              expr::stream
#define ExprAttr                expr::attr
#define ExprFormatDateTime      expr::format_date_time
#define PosixTimeType           boost::posix_time::ptime
#define ExprMessage             expr::smessage

#define FileName                keywords::file_name
#define RotationSize            keywords::rotation_size
#define TimeBasedRotation       keywords::time_based_rotation
#define Format                  keywords::format
#define Target                  keywords::target
#define MaxSize                 keywords::max_size
#define MinFreeSpace            keywords::min_free_space
#define RotationAtTimeInterval  sinks::file::rotation_at_time_interval

#define Reset_Filter            reset_filter                                /*The reset_filter method removes the global logging filter.*/
#define Set_Filter              set_filter                                  /*The set_filter method sets the global logging filter to every log record that is processed.*/
#define SetFormatter            set_formatter
#define RecordView              logging::record_view
#define FormattingOstream       logging::formatting_ostream
#define SharedPtr               boost::shared_ptr
#define MakeShared              boost::make_shared
#define SinkFileBackend         sinks::text_file_backend
#define LockedBackend           locked_backend
#define SetFileCollector        set_file_collector
#define MakeCollector           sinks::file::make_collector
#define AddSink                 add_sink                                    /*The add_sink method adds a new sink. The sink is included into logging process immediately after being added and until being removed. No sink can be added more than once at the same time. If the sink is already registered, the call is ignored.*/
#define RemoveSink              remove_sink                                 /*The remove_sink method removes the sink from the output. The sink will not receive any log records after removal. The call has no effect if the sink is not registered.*/
#define RemoveAllSinks          remove_all_sinks                            /*The remove_all_sinks method removes all registered sinks from the output. The sinks will not receive any log records after removal.*/
#define Flush                   flush
#define ScanForFiles            scan_for_files
#define ScanAll                 sinks::file::scan_all
#define ScanMatching            sinks::file::scan_matching

#define SetExceptionHandler     set_exception_handler
#define ExceptionSuppressor     logging::make_exception_suppressor
#define MakeExceptionHandler    logging::make_exception_handler

typedef sinks::synchronous_sink < SinkFileBackend >     sink_type;

static src::logger lg;
#define WriteToLog              BOOST_LOG(lg)

/*Defining Macros for Writing log with Severity*/
//BOOST_LOG_INLINE_GLOBAL_LOGGER_DEFAULT(my_logger, src::logger_mt)
//static src::severity_logger< logging::trivial::severity_level > slg;

#define LogTrace        BOOST_LOG_SEV(obj->slg, logging::trivial::trace)        
#define LogDebug        BOOST_LOG_SEV(obj->slg, logging::trivial::debug)        
#define LogInfo         BOOST_LOG_SEV(obj->slg, logging::trivial::info)     
#define LogWarning      BOOST_LOG_SEV(obj->slg, logging::trivial::warning)  
#define LogError        BOOST_LOG_SEV(obj->slg, logging::trivial::error)        
#define LogFatal        BOOST_LOG_SEV(obj->slg, logging::trivial::fatal)        
#define _1MB    (1 * 1024 * 1024)
#define _10MB   (10 * 1024 * 1024)
#define datefmt ("_%Y-%b-%d")
#define timefmt ("_%H-%M-%S")

using namespace std;
class CBoostLogger
{
private: 
    SharedPtr< SinkFileBackend > backend;
    SharedPtr< sink_type > sink;
public:
    src::severity_logger< logging::trivial::severity_level > slg;
    CBoostLogger(void);
    ~CBoostLogger(void);
    bool StartLogger(struct FileFormat *sff);
    bool StopLogger();
    bool SetFilter(short severitylevel);
    bool SetFormat(struct LogFormat *sle);

private:
    friend void Formatter(logging::record_view const& rec, logging::formatting_ostream& strm);
};
/*This Structure is used to set the formats for file*/
struct FileFormat
{
bool includedatetofile;
bool includetimetofile;
string filename;
string filelocation;
unsigned long rotationsize;
unsigned long maxsize;

FileFormat() :  includedatetofile(false),
                includetimetofile(false),
                filename("log")         ,
                filelocation("C:/Log")  ,
                rotationsize(_1MB)      ,
                maxsize(_10MB)          {};
};

struct LogFormat
{
bool Set_LineID;
bool Set_Time;
bool Set_Severity; 
bool Set_ThreadID;
bool Set_Message;

LogFormat() :   Set_LineID(true)    ,
                Set_Time(true)      ,
                Set_Severity(true)  ,
                Set_ThreadID(true)  ,
                Set_Message(true)   {};

LogFormat(bool lineid, bool time, bool severity, bool threadid, bool message) 
    :   Set_LineID(lineid)      ,
        Set_Time(time)          ,
        Set_Severity(severity)  ,
        Set_ThreadID(threadid)  ,
        Set_Message(message)    {};
};

BoostLogger.cpp：

#pragma once
#include "BoostLogger.h"

////////////////////////////////////
//Global Declarations
////////////////////////////////////

bool SetLineID, SetTime, SetSeverity, SetThreadID, SetMessage ;

CBoostLogger::CBoostLogger(void)
{
    cout << "Calling CBoostLogger Constructor..." << endl;
    SetFilter(2);
    //GetLoggingCore()->SetExceptionHandler(MakeExceptionHandler<std::runtime_error,std::exception>(handler()));
    GetLoggingCore()->SetExceptionHandler(ExceptionSuppressor());
}

CBoostLogger::~CBoostLogger(void)
{
    GetLoggingCore() -> Reset_Filter();     
    GetLoggingCore() -> RemoveAllSinks();
}

bool CBoostLogger::StartLogger(struct FileFormat *sff )
{
    if(sff->includedatetofile)
        sff->filename += datefmt;
    if(sff->includetimetofile)
        sff->filename += timefmt;
    sff->filename += ".log";
    backend = MakeShared < SinkFileBackend >(
                FileName            =   sff->filename,                                                                                  /*< file name pattern >*/
                RotationSize        =   sff->rotationsize                                                                               /*< rotate files for every 1M >*/
                );  
    sink = MakeShared < sink_type > (backend);
    LogFormat sle;
    SetFormat(&sle);
    sink->LockedBackend()->SetFileCollector
        ( 
            MakeCollector
            ( 
                Target  =   sff->filelocation ,                 /*File Storage Location*/   
                MaxSize =   sff->maxsize                        /*Limit for folder : maxsize, where initially maxsize = 10M*/
            )
        );
    sink->LockedBackend()->ScanForFiles(ScanAll);
    GetLoggingCore()->AddSink(sink);

    AddCommonAttr();    
    BOOST_LOG_SEV(this->slg, logging::trivial::info) << "Logger Starts";
    return true;
}

/*This function used to remove the registered sink from core.*/
bool CBoostLogger::StopLogger()
{
    BOOST_LOG_SEV(this->slg, logging::trivial::info) << "Logger Stops";
    GetLoggingCore()->RemoveSink(sink);
    GetLoggingCore()->Flush();
    return true;
}

    /*This function is used to set filter level. */
bool CBoostLogger::SetFilter(short severitylevel)
{
    GetLoggingCore()->Set_Filter                
    (
        LoggingSeverity >= severitylevel
    );
    return true;
}

/*This function is used to set format for log. */
bool CBoostLogger::SetFormat(struct LogFormat *sle)
{
    SetLineID   = sle->Set_LineID;
    SetTime     = sle->Set_Time;
    SetSeverity = sle->Set_Severity;
    SetThreadID = sle->Set_ThreadID;
    SetMessage  = sle->Set_Message;
    sink->SetFormatter(&Formatter);
    return true;
}

/*This function is used to set format for the log file.*/
void Formatter(RecordView const& rec, FormattingOstream& strm)
{
    if(SetLineID)   
    {
        strm << Extract < unsigned int >    ("LineID", rec) << "\t";    // Get the LineID attribute value and put it into the stream
    }
    if(SetTime) 
    {
        strm << Extract < PosixTimeType >   ("TimeStamp", rec) << "\t"; // Get the TimeStamp attribute value and put it into the stream
    }
    if(SetSeverity) 
    {
        strm << "[ " << rec[LoggingSeverity] << " ]\t";                 // Get the Severity attribute value and put it into the stream
    }
    if(SetThreadID) 
    {
        strm << Extract < ThreadValueType > ("ThreadID", rec )<<"\t";   // Get the ThreadID attribute value and put into the stream
    }
    if(SetMessage)  
    {
        strm << rec[ExprMessage];                                       // Finally, put the record message to the stream
    }
}

struct handler
{
  void operator()(const runtime_error &ex) const
  {
    std::cerr << "\nRuntime_error: " << ex.what() << '\n';
  }

  void operator()(const exception &ex) const
  {
    std::cerr << "Exception: " << ex.what() << '\n';
  }
};

源.cpp：

#include "BoostLogger.h"

void func_thread(std::string fn,string fl,int num)
{
    std::string buf = "";
    char str[20];
    buf += itoa(num, str, 10);
    fn += buf;

    CBoostLogger *obj = new CBoostLogger();
    FileFormat formatobj;
    formatobj.filename = fn;
    formatobj.filelocation = fl;
    formatobj.includedatetofile = true;
    formatobj.includetimetofile = true;
    obj->StartLogger(&formatobj);

    for(int i=0;i<10000;i++)
    {
        LogTrace    << "Trace message new " << fn;
        BOOST_LOG_SEV(obj->slg,logging::trivial::trace) << "Test";

        LogDebug    << "Debug Message new"  << fn;
        LogInfo     << "Info  message" << fn;
        LogWarning  << "Warning  message new" << fn;
        LogError    << "An error  message new" << fn;
        LogFatal    << "A fatal  message new" << fn;
    }   

    LogFormat sle(true,false,false,false,true);
    obj->SetFormat(&sle);   

    for(int i=0;i<10000;i++)
    {
        LogTrace        << "Trace message new " << fn;
        LogDebug        << "Debug Message new"  << fn;
        LogInfo     << "Info  message" << fn;
        LogWarning  << "Warning  message new" << fn;
        LogError        << "An error  message new" << fn;
        LogFatal        << "A fatal  message new" << fn;
    }   
    obj->StopLogger();
    delete obj;
}

int main()
{
    //This following code makes problem.
    boost::thread *thread1 = new boost::thread(&func_thread,"Thread_","C:/BoostLog",1);
    boost::thread *thread2 = new boost::thread(&func_thread,"Thread_","C:/BoostLog",2);
    thread1->join();
    thread2->join();

    /*
    //This following is not making that problem.
    boost::thread_group t_groups;
    for(int i=1;i<=5;i++)
    {
        t_groups.create_thread(boost::bind(&func_thread,"Thread","C:/BoostLog",i));
        t_groups.join_all();
    }

    boost::thread_group tgroup;
    boost::thread *threads;
    for(int i=0;i<20;i++)
    {
        threads=new boost::thread(&func_thread,"Thread","C:/BoostLog",i);
        tgroup.add_thread(threads);
        std::cout << "\nThread "<<i<<" is created whose id is : "<<threads->get_id();
        threads->join();
    }   
    */

    return 0;
}

如果您需要有关此的更多信息，请询问我。

我想使用 boost 库创建线程安全记录器。如果可以的话，请帮助我。

还有一件事，如果可能的话，线程必须同时运行。

谢谢。

4

4 回答 4

1

为了碰撞使用

BOOST_LOG_ATTRIBUTE_KEYWORD(tag_attr, "Tag", std::string)
或
BOOST_LOG_SCOPED_THREAD_TAG("Tag", tag_)

有关更多详细信息，您可以在下面查看：

Boost.log：当它使用 add_file_log() 函数时，如何防止输出被复制到所有添加的流中？
作者：蒂亚古

于 2016-09-12T13:10:41.807 回答
0

我不确定您所说的“两个线程冲突”是什么意思，但您的代码的第一个直接问题是您使用的是非线程安全的记录器src::logger和src::severity_logger. 线程安全的对应项是src::logger_mtand src::severity_logger_mt（例如，请参见此处）。

如果您想将不同线程生成的日志分离到不同的文件中，您可以尝试使用text_multifile_backend基于“ThreadID”属性的文件名生成器，您通过logging::add_common_attributes()在初始化代码中的调用添加该属性。链接页面中有一个示例。

顺便说一句，您不应该在每次调用logging::add_common_attributes()时CBoostLogger::StartLogger都调用，这发生在每个线程中。属性只需添加一次。

由于您正在为每个线程创建一个替代解决方案，因此为接收器添加CBoostLogger设置一个过滤器。CBoostLogger::StartLogger过滤器必须传递具有当前线程 ID 的记录并丢弃其余记录。你可以这样做：

bool CBoostLogger::StartLogger(struct FileFormat *sff )
{
    // ...
    sink = MakeShared < sink_type > (backend);

    // Get the current thread id
    typedef logging::attributes::current_thread_id::value_type thread_id;
    thread_id id = logging::attributes::current_thread_id().get_value().extract_or_throw< thread_id >();

    // Set the filter
    sink->set_filter(expr::attr< thread_id >("ThreadID") == id);

    // ...
}

如果您想提高代码的并发性，可以尝试避免代码中的全局记录器。相反，在线程本地存储中创建非线程安全记录器。根据您的语言版本，您可以使用thread_local或boost::thread_specific_ptr。请注意，在后一种情况下，您必须确保记录器在首次使用之前已初始化。在某些情况下，也可以将记录器保留在线程的堆栈中。

于 2016-02-29T13:09:08.180 回答
0

我建议查看 boost::scoped_lock范围锁文档 如果您只想使每个函数线程安全，请使用带有互斥成员变量的范围锁。但是，如果你想同步你的线程并且它们的运行查看 boost::condition_variable

于 2016-02-29T12:02:44.823 回答
0

处于需要从多个线程进行低延迟日志记录的位置，我最近做了一些搜索。

基本要求

就我而言，一个基本要求是记录事件的时间应该是固定的，并且越短越好。我见过的很多“多线程”日志记录选项都依赖于此（据我所知，log4cpp，boost mt loggers）。

嵌入了某种互斥锁以确保线程安全的单个记录器不会为使用它的每个线程提供有保证的最大记录时间。当一个线程尝试记录时，可能有十几个其他线程都在同一个互斥锁上竞争。所以线程安全不会扩大规模，也保证低延迟。

理想

需要的是记录器始终可供线程使用，事件被填充到某种队列中，并且在另一端有一个单独的线程将事件从队列中拉出并将它们写入文件或其他任何东西。

阿帕奇 log4cpp

Apache log4cpp 接近这一点 - 它有一个 AsyncAppender。我说接近；虽然它有后端线程调用一个附加的任何其他附加程序，但前端不能在一堆线程之间共享，除非它们都在同一个互斥体上争斗。但至少写入文件的行为与日志记录是分离的。这对于确保线程不被日志阻塞大有帮助。

日志4cpp

Log4cpp 有一个 BufferingAppender （文档中没有提到，但它在代码中）。这有一个队列，但没有像 log4cxx 的 AsyncAppender 这样的调度程序线程。这可以用作模板来构建更好的东西。

升压日志

这是一堆令人讨厌的、可怕的、丑陋的、难以理解且文档不完整的代码。我还不能准确地弄清楚它对线程和我的理想实际上可以做什么，但我认为它的 asynchronous_sink 可以完成这项工作。就像 Apache log4cxx 一样，日志前端也使用互斥锁来使其线程安全。

零MQ

我在 Log4cxx 和 Boost 日志中看到的问题是日志架构灵活性的空间不大。我真正想要的是你可以用 ZeroMQ 做的模式类型。

我开始确信我需要编写自己的日志库。ZeroMQ 有一些非常好的模式（尤其是 PUB/SUB），使用它来将日志消息从线程推送到中央日志线程似乎是一个好主意，特别是考虑到 ZeroMQ 的架构灵活性。

ZeroMQ 套接字将充当缓冲区以吸收突然的日志记录需求，而中心线程则将其全部写入磁盘。如果记录的持续速率不超过硬盘带宽，那就没问题了。

我可能会尝试将其压缩到 log4cpp 中，并将其用作每个线程类别/附加器之间的传输，以及执行实际输出的中央附加器。不过，这会有点棘手。ZeroMQ 传输字节，而不是对象。所以我可能不得不序列化 log4cpp 事件......然后提出了使用什么序列化等等的问题，等等，在我知道它之前，它会变成一个令人讨厌的大效率低下的怪物。

于 2016-04-20T00:07:19.663 回答