mutex C++ good usage - c++

Question

I've some trouble with mutex, consider this exemple :
boost::mutex m;
void thread1_unstack(std::stack<std::string>& msg) {
while (true) {
if (msg.empty()) continue;
m.lock();
std::string msg_string = msg.top();
msg.pop();
std::cout << msg_string << std::endl;
m.unlock();
}
}
void thread2_stack(std::stack& msg) {
while (1) {
msg.push("very long message");
}
}
void wait_for_finish(std::stack& msg) {
while (!msg.empty()) sleep(1);
}
int main() {
std::stack<std::string> msg;
boost::thread t1 = boost::thread(boost::bind(&thread1_unstack, boost::ref(msg));
boost::thread t2 = boost::thread(boost::bind(&thread2_stack, boost::ref(msg));
wait_for_finish(msg);
t1.stop();
t2.stop();
}
So the probleme is with the function wait_for_finish. The function detect the stack is empty when msg.pop() is called, so thread are stopped juste after and sometimes, the message (std::cout) is not totally printed on the screen.
So I would like "lock" msg variable for thoses 3 lines :
std::string msg_string = msg.top();
msg.pop();
std::cout << msg_string << std::endl;
like that, wait_for_finish don't detect the stack is empty during std::cout.
I'm tryed to lock a boost::mutex and unlock it at the end, but nothing changed.
So I don't know how to solve it

Answer 1

you have to guard all access with a mutex:
boost::mutex m;
void thread1_unstack(std::stack<std::string>& msg) {
while (true) {
m.lock();
bool msgEmpty = msg.empty();
m.unlock();
if (msgEmpty) continue;
m.lock();
std::string msg_string = msg.top();
msg.pop();
std::cout << msg_string << std::endl;
m.unlock();
}
}
void thread2_stack(std::stack& msg) {
while (1) {
m.lock();
msg.push("very long message");
m.unlock();
}
}
void wait_for_finish(std::stack& msg) {
while(true) {
m.lock();
bool msgEmpty = msg.empty();
m.unlock();
if(msgEmpty) break;
sleep(1);
}
}
int main() {
std::stack<std::string> msg;
boost::thread t1 = boost::thread(boost::bind(&thread1_unstack, boost::ref(msg));
boost::thread t2 = boost::thread(boost::bind(&thread2_stack, boost::ref(msg));
wait_for_finish(msg);
t1.stop();
t2.stop();
}

Answer 2

Comments in our discussion reveal that you're using some kind of thread-safe waitable container. You need to stop the thread with its cooperation to make sure it has time to finish any work it's supposed to do on the last object. I would suggest this approach:
Have a stop flag that's either atomic or protected by a mutex. It should start out cleared.
When the thread gets an object from the container, before it prints it, it checks the stop flag. If the flag is set, the thread terminates.
When you want to stop the thread, set the stop flag, add a dummy object to the container, and then join the thread.
The dummy object unblocks the thread, and it won't get printed because the thread won't print with the stop flag set. By joining the thread, you ensure it's finished all the work it has to do before you terminate.
You can also use the "object of death" approach. For example, say it's not possible for your code to ever queue an empty string -- you could use an empty string as an "object of death". It works like this:
When you get an object from the container, check if it's the object of death. If it is, terminate.
To cause the thread to terminate, queue the object of death and then join the thread.
This has the same behavior. Queuing the object of death unblocks the thread (because the container is no longer empty and it only blocks if it is) and guarantees the thread will terminate when it's done (since the thread checks as soon as it unqueues it). Joining the thread ensures it has completely finished processing all objects prior to the object of death.