跨线程同步C ++错误日志文件

Question

Can any one provide a sample code to achieve sync when a particular log file is accessed by multiple threads. I have heard of using a critical section object but not clear on how to use the same.

Answer 1

The details of the implementation will vary depending on which platform (Win32, Posix, ...) you are, and on which library you use (QT, boost, ...). However, the general idea will be the same, as the primitive that you can use have equivalents.

This series of articles should give you a good understanding of the available option on the different platform, and what are the equivalences.

With this you should be able to write a CriticalSection class:

class CriticalSection
{
    // System specific object

public:
    CriticalSection();
    ~CriticalSection();

    void Lock();
    void Unlock();
};

Then, to send data to your log file, you'll acquire the lock, send the data and then release the lock.

static CriticalSection gLogFileCS;
static std::ofstream*  gLogFilePtr;

void SendLogMessage(const char* message)
{
    gLogFileCS.Lock();
    gLogFilePtr->write(message);
    gLogFileCS.Unlock();
}

You should probably use RAII to ensure that you always unlock the CriticalSection when you're done with it. You'll write a CriticalSectionScopeLock class,

class CriticalSectionScopeLock
{
    CriticalSection& CriticalSection_;

public:
    CriticalSectionScopeLock(CriticalSection& cs)
    : CriticalSection_(cs)
    {
        cs.Lock();
    }

    ~CriticalSectionScopeLock()
    {
        cs.Unlock();
    }
};

and then the SendLogMessage function can be rewritten like that:

void SendLogMessage(const char* message)
{
    CriticalSectionScopeLock lock(gLogFileCS);
    gLogFilePtr->write(message);
}

This can be improved by posting message in a queue (you take the lock when pushing in the queue), and then having another thread writing data to the file. This will reduce contention on the lock, as writing to the disk can block the current thread, and it is generally a bad idea to have a thread block while holding a synchronization resource.

enum MessageType
{
    MessageQuit,
    MessageLog,
};

struct LogThreadMessage
{
    MessageType type;
    char*       data;
};

static CriticalSection gLogThreadQueueCS;
static std::list< LogThreadMessage > gLogThreadQueue;

void StartupLogThread(const char* filename)
{
    // System specific stuff to create a thread, and have
    // it run the LogThreadLoop function.
}

static void LogThreadLoop(std::ostream& logFile)
{
    for (;;)
    {
        std::list< LogThreadMessage > queue;
        {
            CriticalSectionScopeLock lock(gLogThreadQueueCS);
            queue.swap(gLogThreadQueue);
        }

        while (!queue.empty())
        {
            LogThreadMessage msg = queue.front();
            queue.pop_front();

            switch (msg.type)
            {
                case MessageQuit:
                    return;

                case MessageLog:
                    logFile.write(msg.data);
                    break;
            }
        }

        sleep(10);
    }
}

void PostLogThreadMessage(const LogThreadMessage& msg)
{
    CriticalSectionScopeLock lock(gLogThreadQueueCS);
    gLogThreadQueue.insert(gLogThreadQueue.end(), msg);
}

void SendLogMessage(char* message)
{
    LogThreadMessage msg;
    msg.type = MessageLog;
    msg.data = message;

    PostLogThreadMessage(msg);
}

void StopLogThread()
{
    LogThreadMessage msg;
    msg.type = MessageLog;
    msg.data = message;

    PostLogThreadMessage(msg);
}