multithreading – A simple multithreaded FileLogger in C ++

In order to learn more about multithreading programming in C ++, I implement a basic multithreaded recorder.

I am using a std :: deque to store messages in a FileLogger class. Whenever a thread logs a message; this message is pushed to the back of the deque.

In a separate thread, the FileLogger checks for messages in the deque and, if it does, writes them to the file.

Access to the deque is guarded by a mutex.

In order to facilitate connection from anywhere; the recorder is implemented as a singleton.

Is my code correct? How can it be improved?

// FileLogger.h:
class FileLogger
    static void initialize(const char* filePath) { // called by main thread before any threads are spawned
        instance_ = new FileLogger(filePath);
    static FileLogger* instance() { // called from many threads simultaneously
        return instance_;
    void log(const std::string &msg);
    FileLogger(const char* filePath);
    void writeToFile();
    static FileLogger*     instance_;
    std::deque messages;
    std::mutex         messagesMutex; // lock/unlock this each time messages is pushed or popped
    std::ofstream               fout;
    std::thread         writerThread;
// FileLogger.cpp:
FileLogger* FileLogger::instance_ = nullptr;

void FileLogger::writeToFile() {
    for (;;) {
        std::string message;
        while (messages.empty()) {
        message = messages.front();
        fout << message << std::endl << std::flush;

FileLogger::FileLogger(const char* filePath) {;
    std::thread t(&FileLogger::writeToFile, this);
    writerThread = std::move(t);

void FileLogger::log(const std::string &msg) {
    std::lock_guard lg(messagesMutex);