Memory Corruption on c++ multithreaded application - c++

Question

I am developing a multithreaded C++ application, and developed a module for logging. The logging module is a static class, which I call using Logger::Log(string file, string message), that fills a static queue with a pair<string*,string*> The queue itself is a queue<<pair<string*,string*>*>. Everything is saved as a pointer, as I was trying to avoid garbage collection, and believe pointer variables need specific delete to free the memory.
Now, when one of the threads wants to log something, it calls the Log method, which in turn appends to the end of the queue.
Another thread runs through the queue, pops items and writes them to the designated file.
For some reason, some of the text being written to the file is corrupted, as I am losing part of the begginning or the end of the message.
For example, if I call Log("file", "this is my message"), inside the Log method I am prepending a timestamp, and creating a new string, because I thought the original string might be overwritten, but it still happens.
The problem is that in some situations, what is being written to the file is the timestamp, plus only the end of the message.
This is the full code of the Logger class:
#include "Logger.h"
queue<pair<string*, string*>*> Logger::messages;
boost::mutex Logger::loggerLock;
void Logger::CleanOldFiles(vector<string> files){
for (vector<string>::iterator it = files.begin(); it != files.end(); ++it) {
string filePath = boost::filesystem::current_path().string() + "\\" + *it;
int result = remove(filePath.c_str());
}
}
void Logger::Init() {
Logger::messages = queue<pair<string*, string*>*>();
boost::thread workerThread(Logger::Process);
//workerThread.start_thread();
}
void Logger::RawLog(string file, string message) {
loggerLock.lock();
string *f = new string(file);
string *m = new string(message + "\n");
messages.push(new pair<string*, string*>(f, m));
loggerLock.unlock();
}
void Logger::Log(string file, string message) {
loggerLock.lock();
string *f = new string(file);
string *m = new string(Functions::CurrentTime() + " (" + boost::lexical_cast<string>(boost::this_thread::get_id()) + "): " + message.c_str() + "\n");
messages.push(new pair<string*, string*>(f, m));
loggerLock.unlock();
}
void Logger::Process() {
while (true) {
if (Logger::messages.size() == 0) {
boost::this_thread::sleep(boost::posix_time::milliseconds(200));
continue;
}
loggerLock.lock();
pair<string*, string*> *entry = messages.front();
messages.pop();
loggerLock.unlock();
ofstream file(boost::filesystem::current_path().string() + "\\" + *(entry->first), ofstream::binary | ofstream::app);
file.write(entry->second->c_str(), entry->second->length());
file.close();
delete entry->first;
delete entry->second;
delete entry;
//cout << entry->second;
}
}
I hope I made myself clear enough...
I do not understand why this is happening, can anyone give me some hints on how to avoid this?
Thanks in advance.

Answer 1

The Logger::Log must be made MT-safe, otherwise you can get two or more threads trying to log something simultaneously. A simplest way to make it MT-safe is a mutex.

Answer 2

std::queue is not thread-safe. You need to lock access to all the shared objects or to use thread-safe queue implementation like TBB provides.

Answer 3

if (Logger::messages.size() == 0) {
Because messages isn't thread safe, you can't call any functions on it when you don't hold the lock. Also, you are still missing delete calls for the string*s.
You can always just do this:
void Logger::Process()
{
while (true)
{
loggerLock.lock();
if (Logger::messages.size() == 0)
break;
loggerLock.unlock();
boost::this_thread::sleep(boost::posix_time::milliseconds(200));
}
pair<string*, string*> *entry = messages.front();
messages.pop();
loggerLock.unlock();
ofstream file(boost::filesystem::current_path().string() + "\\" +
*(entry->first), ofstream::binary | ofstream::app);
file.write(entry->second->c_str(), entry->second->length());
delete entry->first;
delete entry->second;
file.close();
}
However, for future reference:
1) Don't use pointers this way. Just use a queue of pairs of strings. The pointers don't buy you anything.
2) Use some sane synchronization mechanism like a condition variable. Don't use sleep for synchronization.
3) Use scoped locks and RAII so you don't forget an unlock.

Answer 4

I apologize for the work I might have caused for all trying to help me, but I corrected the issue. This was actually no memory corruption issue, and my assumption made me search for something where there was no problem.
The issue was on the calling threads, and on the form I was creating the log strings. I was concatenating strings in the wrong way...damn those other programming languages ;)
I was doing something such as Logger::Log("Message: " + integerVariable), which is fact was shifting the string to the right (at least I believe that was what it was doing). When I casted all those variables to strings, everything started working. Thank you for all your help anyway.