Моя программа не поддерживает многопотоковое ведение журнала при использовании библиотеки повышения

В настоящее время я создаю класс, который должен использоваться для целей регистрации.

Но здесь одна проблема, он не поддерживает синхронизацию потоков. Нет проблем, когда я запускаю один за другим поток. Но есть проблема, когда я запускаю два или более потоков одновременно.

Проблема, с которой я сталкиваюсь: «Если я создаю два потока, чтобы создать два отдельных журнала, но два потока сталкиваются и записывают свои сообщения журнала в оба файла».

Если кто-нибудь обнаружит проблему, пожалуйста, помогите мне решить ее.

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. Помоги мне, если сможешь.

И еще одна вещь, если возможно потоки должны работать одновременно.

Благодарю.

1

Решение

Для столкновения используйте

BOOST_LOG_ATTRIBUTE_KEYWORD (tag_attr, «Tag», std :: string)
или же
BOOST_LOG_SCOPED_THREAD_TAG («Тег», тег_)

Для более подробной информации, вы можете проверить это ниже здесь:

Boost.log: как предотвратить дублирование вывода во все добавленные потоки при использовании функции add_file_log ()?

Тиягу

1

Другие решения

Я бы порекомендовал посмотреть в boost :: scoped_lock документация блокировки области
Если вы просто хотите сделать каждый поток функций безопасным, используйте блокировку с областью действия с переменной-членом mutex. Однако, если вы хотите синхронизировать ваши потоки и запускать их, посмотрите на boost :: condition_variable

0

Я не уверен, что вы подразумеваете под «столкновением двух потоков», но первая непосредственная проблема с вашим кодом заключается в том, что вы используете не поточно-безопасные регистраторы src::logger а также src::severity_logger, Потокобезопасные аналоги src::logger_mt а также src::severity_logger_mt (увидеть Вот, например).

Если вы хотите разделить журналы, созданные разными потоками, в разные файлы, вы можете попробовать использовать text_multifile_backend с генератором имени файла на основе атрибута «ThreadID», который вы добавляете logging::add_common_attributes() позвоните в ваш код инициализации. На связанной странице есть пример.

Кстати, вы не должны звонить logging::add_common_attributes() каждый раз CBoostLogger::StartLogger называется, что происходит в каждом потоке. Атрибуты должны быть добавлены только один раз.

Альтернативное решение, так как вы создаете CBoostLogger для каждого потока, это установить фильтр для раковины CBoostLogger::StartLogger добавляет. Фильтр должен передавать записи, которые имеют идентификатор текущего потока, и отбрасывать остальные. Вы можете сделать это так:

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. Обратите внимание, что в последнем случае вы должны убедиться, что регистратор инициализирован перед его первым использованием. В некоторых случаях также возможно сохранить регистратор в стеке потока.

0

Будучи в состоянии нуждаться в ведении журналов с низкой задержкой из нескольких потоков, я недавно немного поохотился.

Основное требование

Насколько я понимаю, основным требованием является то, что время для регистрации события должно быть фиксированным, и чем короче, тем лучше. Множество «многопоточных» вариантов ведения журнала, которые я видел, не работают (log4cpp, насколько я могу судить, boost mt logger).

Единственный логгер, в который встроен какой-то мьютекс для обеспечения безопасности потока, не обеспечивает каждому потоку, использующему его, гарантированное максимальное время регистрации. Когда один поток пытается войти в систему, может случиться так, что с одним и тем же мьютексом конкурируют дюжина других потоков. Таким образом, потокобезопасность не увеличивается, а также гарантирует низкую задержку.

Идеал

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

Apache log4cpp

Apache log4cpp приближается к этому — у него есть AsyncAppender. Я говорю близко; хотя у него есть внутренний поток, вызывающий все присоединенные к нему дополнительные приложения, внешний интерфейс не может быть разделен между несколькими потоками, если все они не борются за один и тот же мьютекс. Но, по крайней мере, акт записи в файл отделен от регистрации. Это имеет большое значение для обеспечения того, чтобы поток не был заблокирован журналом.

log4cpp

Log4cpp имеет BufferingAppender (не упоминается в документации, но он есть в коде). У этого есть очередь, но нет потока диспетчера, такого как AsyncAppender log4cxx. это мог использоваться в качестве шаблона для создания чего-то лучшего.

Boost Log

Это ужасная, ужасная, большая, уродливая куча сложного для понимания и не полностью документированного кода. Я еще не смог точно понять, что он может делать с потоками и моим идеалом, но я думаю, что его asynchronous_sink делает свою работу. Как и Apache log4cxx, похоже, что внешний интерфейс журналирования также использует мьютекс, чтобы сделать его потокобезопасным.

ZeroMQ

Проблема, которую я вижу с Log4cxx и Boost log, состоит в том, что не так много места для регистрации архитектурной гибкости. Что мне действительно нужно, так это тип паттернов, которые вы можете использовать с ZeroMQ.

Я становлюсь убежденным, что мне нужно написать свою собственную библиотеку журналов. У ZeroMQ есть несколько очень хороших шаблонов (особенно PUB / SUB), и использование этого для передачи сообщений журнала из потоков в центральный поток регистрации может показаться изящной идеей, особенно учитывая архитектурную гибкость ZeroMQ.

Сокеты ZeroMQ будут выступать в качестве буферов, чтобы удовлетворить внезапную потребность в записи, в то время как центральный поток будет записывать все это на диск. Если стабильная скорость записи не превышает пропускную способность жесткого диска, все будет хорошо.

Я могу попытаться сжать его в log4cpp и буквально использовать в качестве транспорта между категориями / приложениями потоков и центральным приложением, которое выполняет фактический вывод. Это будет немного сложно, хотя. ZeroMQ транспортирует байты, а не объекты. Поэтому мне, возможно, придется сериализовать события log4cpp … Тогда возникает вопрос о том, какую сериализацию использовать и т. Д. И т. Д., И, прежде чем я это узнаю, он станет неприятным большим неэффективным монстром.

0