🚀 go-pugleaf

"Josh Kirkpatrick" <jkirkpat@softhome.net> wrote in message
news:3f88f22a@newsgroups.borland.com...

> What would be the best method of ensuring that only one
> thread at a time writes to this text file and that the rest of
> the threads wait their turn?

Use a mutex or critical section to synchronize the access to the file.
Whenever a thread wants to access the file, it has to obtain a lock to the
mutex/cs first, and then release it when finished so that another thread can
obtain it later.

Even better, you can wrap the file access into a singleton class, that way
the file is only being accessed directly by a single object and only 1
instance of that object is allowed to be created.  The object can then
handle the sychronizing internally.  I use such an approach in several of my
projects, it works quite well.  For example:

    --- TLogFile.h ---

    #ifndef TLogFileH
    #define TLogFileH

    class TLogFile
    {
    private:
        CRITICAL_SECTION crit;
        TLogFile();
    public:
        ~TLogFile();
        static TLogFile* Instance();
        void Write(const AnsiString &Str);
    };

    #endif


    --- TLogFile.cpp ---

    #include "TLogFile.h"

    TLogFile::TLogFile()
    {
        InitializeCriticalSection(&crit);
    }

    TLogFile::~TLogFile()
    {
        DeleteCriticalSection(&crit);
    }

    TLogFile* TLogFile::Instance()
    {
        static TLogFile log;
        return &log;
    }

    void TLogFile::Write(const AnsiString &Str)
    {
        EnterCriticalSection(&crit);
        try
        {
            // open/create the log file
            // write the Str to the file
            // close the file
        }
        __finally {
            LeaveCriticalSection(&crit);
        }
    }

Then the calling threads can do the following when needed:

    #include "TLogFile.h"

    TLogFile::Instance()->Write("write something to the log");
    ...
    TLogFile::Instance()->Write("write something else to the log");
    ...


Gambit