I had a similar problem and I show you how I solved it. The logic a little bit (not sure if you like it, but I find this way to usually be more maintainable and scalable) . Basically the main thread calls Log that pushes the string into a queue. The access to the queue is synchronized by the queue_mutex. There are 2 additional mutexes: · work_mutex makes Run wait until the queue is *not* empty. · empty_mutex makes WaitForQueueFlush wait until the queue *is* empty. Maybe you can achieve the same combining those two mutexes but I dont have time to try that right now. Hope it can help, Benedetto This is an (untested) code snippet. #include <boost/thread/thread.hpp> #include <boost/thread/xtime.hpp> #include <boost/thread/condition.hpp> #include <boost/foreach.hpp> #include <boost/tr1/functional.hpp> #include <queue> #include <fstream> #include <string> class FileLogger { typedef boost::unique_lock<boost::mutex> unique_lock; std::ofstream logfile; bool running; // this controls the actual push/pop in the queue boost::mutex queue_mutex; // this mutex will be "unlocked" when the queue is empty. // WaitForQueueFlush will wait until it is unlocked and then lock it. // It will be unlocked when eventually the queue becomes empty again. boost::mutex empty_mutex; // this mutex will be "locked" when the queue is empty. // the "Run" method will wait on it until some element is pushed into the queue // and this mutex becomes available. boost::mutex work_mutex; // queue seems to be more appropriate data structure than vector std::queue<std::string> queue; // this saves the current thread... just in case you need it boost::thread * mythread; public: FileLogger(const std::string& filename) : logfile(filename.c_str()) , running(true) { work_mutex.lock(); } ~FileLogger() { running = false; } // this runs in the main thread void Log(const std::string& s) { unique_lock lock(queue_mutex); queue.push(s); if (!work_mutex.try_lock()) { work_mutex.unlock(); } if (empty_mutex.try_lock()) { empty_mutex.unlock(); } } void Log_impl(const std::string& s) { unique_lock lock(queue_mutex); logfile << s << '\n'; } void WaitForQueueFlush() { empty_mutex.lock(); } void start() { mythread = new boost::thread(boost::bind(&FileLogger::Run, this)); } private: void Run() { while( running ) { work_mutex.lock(); unique_lock lock(queue_mutex); std::string s = queue.pop(); Log_impl(s); if (queue.empty()) { empty_mutex.unlock(); } } } }; int main() { FileLogger fileLogger("logfile.txt"); fileLogger.Log(std::string(1000*1000, '*')); // this call should wait, synchronously, until // current queue has been flushed to disk fileLogger.WaitForQueueFlush(); } -----Original Message----- From: boost-users-bounces@lists.boost.org [mailto:boost-users-bounces@lists.boost.org] On Behalf Of Daniel Lidström Sent: Friday, March 05, 2010 7:22 AM To: boost-users@lists.boost.org Subject: [Boost-users] Waiting for a thread on another thread Hello! I have created a simple file logger using the active object pattern. This is intended to offload logging operations to a separate thread, to not disturb the main thread with time- consuming file operations. It works very nicely with boost::thread, but now I have a new desired functionality. The file logger keeps an internal queue of strings that need to be written to file. I want to know, from the main thread, when this queue is empty. To illustrate I have created a minimal, hopefully compilable, sample that shows what I am trying to achieve. #include <boost/thread/thread.hpp> #include <boost/thread/xtime.hpp> #include <boost/thread/condition.hpp> #include <boost/foreach.hpp> #include <boost/tr1/functional.hpp> #include <vector> #include <fstream> #include <string> class FileLogger { typedef boost::unique_lock<boost::mutex> unique_lock; std::ofstream logfile; bool running; boost::thread running_thread; boost::mutex mutex; boost::condition_variable condition; std::vector<std::string> queue; public: FileLogger(const std::string& filename) : logfile(filename.c_str()) , running(true) , running_thread(std::tr1::bind(&FileLogger::Run, this)) { } ~FileLogger() { running = false; condition.notify_one(); running_thread.join(); } void Log(const std::string& s) { unique_lock lock(mutex); queue.push_back(s); } void WaitForQueueFlush() { // ?? } private: void Run() { while( running ) { std::vector<std::string> copyList; { // wait 0.1 s here, for queue to fill up boost::xtime sleepTime; boost::xtime_get(&sleepTime, boost::TIME_UTC); sleepTime.nsec += 100*1000*1000; unique_lock lock(mutex); condition.timed_wait(lock, sleepTime); // fetch the current message list copyList.swap(queue); } BOOST_FOREACH(const std::string& s, copyList) { logfile << s << '\n'; } logfile.flush(); } } }; int main() { FileLogger fileLogger("logfile.txt"); fileLogger.Log(std::string(1000*1000, '*')); // this call should wait, synchronously, until // current queue has been flushed to disk fileLogger.WaitForQueueFlush(); } So the problem is to implement FileLogger::WaitForQueueFlush. How can I signal the main thread when the queue has been emptied? Thanks in advance! Regards, Daniel Lidström Stockholm, Sweden _______________________________________________ Boost-users mailing list Boost-users@lists.boost.org http://lists.boost.org/mailman/listinfo.cgi/boost-users