Member Avatar for amelie

Hi,

I need to write to a file from multiple objects, out of which few objects spawn multiple threads.

Can any one give me some tips.

Thanks.
-ameli

  • 2 Contributors
  • 6 Replies
  • 182 Views
  • 1 Week Discussion Span
  • Latest Post Latest Post by amelie

Dani AI

Generated

Brief summary and practical options. As pointed out, writes from different threads to the same file must be serialized — otherwise output can interleave and become unusable. Reusing a single coordination primitive is fine, but to avoid deadlocks and complexity prefer RAII-style locks (std::mutex / std::lock_guard) or isolate all file I/O on one thread. Redirecting std::cout to a file does not remove the need to synchronize: iostream objects are not safe for concurrent writes without external coordination.

A simple, safe approach is a single logger object that owns one std::ofstream and a mutex. Keep the lock scope tiny: build the full message first, then lock and write.

class Logger {
    std::mutex mtx;
    std::ofstream out;
public:
    Logger(const std::string& file) : out(file, std::ios::app) {}
    void log(const std::string& msg) {
        std::lock_guard<std::mutex> lk(mtx);
        out << msg << '\n';
    }
    ~Logger() { out.flush(); out.close(); }
};

If you need high throughput or want to avoid blocking worker threads, push messages into a thread-safe queue and have one background writer thread consume and flush them. This reduces contention and the chance of deadlocks because workers never hold the file lock while formatting messages.

// sketch: producer pushes string, worker thread writes from queue
// (use std::mutex, std::condition_variable and std::queue; join worker on shutdown)

Practical cautions and checklist: open the file in append mode (std::ios::app) if you want appends; prefer leaving the ofstream open for performance but flush/close cleanly on shutdown; do not hold locks while formatting or calling other subsystems; avoid nested locks or logging while holding unrelated locks; if multiple processes write the same file use OS-level file locks or separate logs per process; consider mature logging libraries (spdlog, Boost.Log) for production features (rotation, levels, async).

Recommended Answers

All 6 Replies

Member Avatar for Ancient Dragon

Only one object and one thread can write to a file at one time. The reason should be obvious -- if two threads attempt to write to the file at the same time the result will be an unpredictible mixture of the data. You can take at least a couple approaches to the problem

1. create one function that does all the writing. All objects/threads pass write requests to that one function.

2. Synchronize access to the file -- most commonly use a semiphore for that purpose. A semiphone is an operating system resource that blocks threads when it is in use by another thread.

Member Avatar for amelie

Thanks for the suggestions.
I'm worried about extensive use of semaphores.
I've already used few semaphores elsewhere, and worried about avoiding deadlock scenarios.

I've an alternative thought, how abt writing with cout and redirecting the output to a file? Would the problems associated with normal file also present here?

Member Avatar for Ancient Dragon

redirecting cout to a file would solve nothing. maybe you can use an existing semaphore instead of creating yet another one.

Member Avatar for amelie

Ok. I'll try reusing the semaphore.

I've come across a code piece wherein one fstream object and one ofstream* are used as data members in the class providing the writing to log functionality?

I could not understand why do we need fstream object, where the purpose is only to write to the file.

Member Avatar for Ancient Dragon

I could not understand why do we need fstream object, where the purpose is only to write to the file.

because the program can't write to a file without it. It probably opens the file once and leaves it open for a very long time, and passes the fstream object around to other methods in the class. I don't like leaving a file open for long periods of time -- my logging function closes the stream as quickly as possible to (1) reduce possibility of corrupt file in case of abnormal termination of the program and (2) other programs, processes and people can easily access the file.

Member Avatar for amelie

Hi,

Can you please comment on the below approach?

1. A global function

writeMsg()
. that locks a sema,
. writes to the file,
.create a fstream object if there is none
.open outstream object if it is not open
.write to the file
//close the file when the application terminates
. unlock sema.

This global function to be accessed from multiple files leading to concurrent invocations from multiple objects and threads.
Thanks.
amelie

Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.