В настоящее время я создаю класс, который следует использовать для ведения журнала.
Но вот одна проблема, он не поддерживает синхронизацию потоков. Нет проблем, когда я запускаю один за другим поток. Но есть проблема, когда я запускаю два или более потока одновременно.
Проблема, с которой я сталкиваюсь: «Если я создаю два потока для создания двух отдельных журналов, но два потока сталкиваются и записывают свои сообщения журнала в оба файла».
Если кто-нибудь найдет проблему, пожалуйста, помогите мне решить ее.
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. Помогите мне, если можете.
И еще одно, если возможно, потоки должны выполняться одновременно.
Спасибо.