我目前正在创建一个应该用于记录目的的类。
但是这里有一个问题，它不支持线程同步。当我逐个运行线程时没有问题。但是当我一次运行两个或更多线程时会出现问题。
我面临的问题是：＆＃34;如果我创建两个线程来创建两个单独的日志，但是两个线程正在冲突并将其日志消息写入两个文件＆＃34;。
如果有人发现问题，请帮我解决。
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';
}
};
Source.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库创建线程安全记录器。如果可以，请帮助我。
另外一件事，如果可能的话，线程必须同时运行。
感谢。
答案 0 :(得分：1)
为了碰撞使用
BOOST_LOG_ATTRIBUTE_KEYWORD（tag_attr，＆＃34; Tag＆＃34;，std :: string）
或
BOOST_LOG_SCOPED_THREAD_TAG（＆＃34; Tag＆＃34;，tag_）
有关详细信息，请在此处查看：
Boost.log: How to prevent the output will be duplicated to all added streams when it uses the add_file_log() function?
通过，Thiyagu
答案 1 :(得分：0)
我建议调查boost :: scoped_lock scoped lock documentation 如果您只想使每个函数线程安全，请使用带有互斥锁成员变量的范围锁。但是，如果要同步线程并运行它们，请查看boost :: condition_variable
答案 2 :(得分：0)
我不确定你的意思＆＃34;两个线程碰撞＆＃34;但是您的代码的第一个直接问题是您使用非线程安全记录器src::logger和src::severity_logger。线程安全的对应方是src::logger_mt和src::severity_logger_mt（例如，请参阅here）。
如果要将不同线程生成的日志分成不同的文件，可以尝试将text_multifile_backend与文件名生成器一起使用，基于＆＃34; ThreadID＆＃34;您在初始化代码中通过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。请注意，在后一种情况下，您必须确保在首次使用之前初始化记录器。在某些情况下，还可以将记录器保留在线程的堆栈中。
答案 3 :(得分：0)
处于需要从多个线程进行低延迟日志记录的位置我最近做了一些狩猎。
基本要求
就我而言，基本要求是记录事件的时间应该是固定的，越短越好。很多＆＃34;多线程＆＃34;记录选项我已经看到了这个（log4cpp，boost mt记录器，据我所知）。
一个嵌入了某种互斥锁的单个记录器，以确保线程安全，不会为每个线程提供保证最大记录时间。当一个线程尝试记录时，可能是在同一个互斥锁上有十几个其他线程在竞争。因此，线程安全不会扩展，也可以保证低延迟。
理想
需要的东西是记录器总是可用于线程，事件被填充到某种队列中，并且另一端有一个单独的线程拉动队列中的事件并将它们写入文件或其他任何东西。
Apache log4cpp
Apache log4cpp接近这个 - 它有一个AsyncAppender。我说接近;虽然它有后端线程调用任何其他附加的appender，但是前端不能在一堆线程之间共享而没有它们都在同一个互斥锁上。但至少写入文件的行为与日志记录是分离的。这对于确保线程不被日志阻止非常有用。
<强> Log4cpp
Log4cpp有一个BufferingAppender（文档中没有提到，但它在代码中有）。这有一个队列，但没有像log4cxx的AsyncAppender那样的调度程序线程。 可以用作模板来构建更好的东西。
提升日志
这是一个令人讨厌的可怕的大丑陋的难以理解和完整记录的代码。我还没有完全弄清楚它对于线程和我的理想究竟能做些什么，但我认为它的asynchronous_sink可以完成这项工作。与Apache log4cxx一样，它看起来像日志记录前端也使用互斥锁来使其线程安全。
<强> ZeroMQ
我在Log4cxx和Boost日志中看到的问题是，记录架构灵活性的空间不大。我真正想要的是你可以用ZeroMQ做的模式类型。
我确信我需要编写自己的日志库。 ZeroMQ有一些非常好的模式（特别是PUB / SUB），使用它来将日志消息从线程推送到中央日志记录线程似乎是一个很好的想法，特别是考虑到ZeroMQ的架构灵活性。
ZeroMQ套接字将充当缓冲区以吸收突然的日志记录需求，而中心线程则将其全部写入磁盘。如果持续的记录速率不超过硬盘带宽，那么它就没问题了。
我可能会尝试将其压缩到log4cpp中，并逐字地将其用作每个线程类别/ appender之间的传输，以及执行实际输出的中央appender。但这有点棘手。 ZeroMQ传输字节，而不是对象。所以我可能需要序列化log4cpp事件...然后提出了使用什么序列化的问题等等。在我知道它之前它会成为一个讨厌的大型低效怪物。