Мой подход к потокобезопасному классу журнала ужасен?

Я смотрел вокруг на различные подходы к проблеме потокового ведения журнала, но я не видел ничего подобного, поэтому я не знаю, ужасно ли это, что я не заметил, потому что я новичок в C ++, потоках и iostreams. Кажется, он работает в базовых тестах, через которые я прошел.

В основном у меня есть класс Log (креатив, я знаю …), у которого есть оператор<< настроить для стандартных манипуляторов, так что я могу весело передать все, что я хочу.

Тем не менее, я знаю, что-то вроде:

std::cout << "Threads" << " will" << " mess" << " with" << "this." << std::endl;

будет потенциально чередоваться, когда несколько потоков записывают в cout (или куда бы ни направлялся поток o Log). Итак, я создал некоторые манипуляторы, специфичные для класса Log, которые позволяют мне делать это:

Log::log << lock << "Write" << " what" << " I" << " want" << std::endl << unlock;

Я просто хочу знать, является ли это по своей сути ужасной идеей, имея в виду, что я готов согласиться с тем, что пользователи класса Log должны быть дисциплинированы с помощью ‘lock’ и ‘unlock’. Я подумал о том, чтобы сделать автоматическую разблокировку ‘std :: endl’, но кажется, что это вызовет больше головной боли … Я думаю, что в любом случае в тестировании должно быть недисциплинированное использование, но если кто-то сможет увидеть способ сделать такое использование вызывающим ошибки времени, это было бы хорошо.

Я также был бы признателен за любые предложения, чтобы сделать мой код чище.

Вот урезанная версия класса для демонстрационных целей; у всего этого есть еще несколько конструкторов, принимающих такие вещи, как имена файлов, поэтому они не имеют отношения к вопросу.

#include <iostream>
#include <thread>
#include <fstream>

class Log{
public:
//Constructors
Log(std::ostream & os);
// Destructor
~Log();
// Input Functions
Log & operator<<(const std::string & msg);
Log & operator<<(const int & msg);
Log & operator<<(std::ostream & (*man)(std::ostream &)); // Handles manipulators like endl.
Log & operator<<(std::ios_base & (*man)(std::ios_base &)); // Handles manipulators like hex.
Log & operator<<(Log & (*man)(Log &)); // Handles custom Log manipulators like lock and unlock.
friend Log & lock(Log & log); // Locks the Log for threadsafe output.
friend Log & unlock(Log & log); // Unlocks the Log once threadsafe output is complete.
private:
std::fstream logFile;
std::ostream & logStream;
std::mutex guard;
};

// Log class manipulators.
Log & lock(Log & log); // Locks the Log for threadsafe output.
Log & unlock(Log & log); // Unlocks the Log once threadsafe output is complete.

void threadUnsafeTask(int * input, Log * log);
void threadSafeTask(int * input, Log * log);

int main(){
int one(1), two(2);
Log log(std::cout);
std::thread first(threadUnsafeTask, &one, &log);
std::thread second(threadUnsafeTask, &two, &log);
first.join();
second.join();
std::thread third(threadSafeTask, &one, &log);
std::thread fourth(threadSafeTask, &two, &log);
third.join();
fourth.join();
return 0;
}

void threadUnsafeTask(int * input, Log * log){
*log << "Executing" << " thread '" << *input << "', " << "expecting " << "interruptions " << "frequently." << std::endl;
}

void threadSafeTask(int * input, Log * log){
*log << lock << "Executing" << " thread '" << *input << "', " << "not expecting " << "interruptions." << std::endl << unlock;
}

// Constructors (Most left out as irrelevant)
Log::Log(std::ostream & os): logFile(), logStream(logFile), guard(){
logStream.rdbuf(os.rdbuf());
}

// Destructor
Log::~Log(){
logFile.close();
}

// Output Operators
Log & Log::operator<<(const std::string & msg){
logStream << msg;
return *this;
}

Log & Log::operator<<(const int & msg){
logStream << msg;
return *this;
}

Log & Log::operator<<(std::ostream & (*man)(std::ostream &)){
logStream << man;
return *this;
}

Log & Log::operator<<(std::ios_base & (*man)(std::ios_base &)){
logStream << man;
return *this;
}

Log & Log::operator<<(Log & (*man)(Log &)){
man(*this);
return *this;
}

// Manipulator functions.
Log & lock(Log & log){
log.guard.lock();
return log;
}

Log & unlock(Log & log){
log.guard.unlock();
return log;
}

Он работает для меня на Ubuntu 12.04 g ++, скомпилирован с:

g++ LogThreadTest.cpp -o log -std=c++0x -lpthread

Куски, имеющие отношение к созданию пользовательских манипуляторов, были бесстыдно Вот но не вините их за мою некомпетентную коппасту.