Why program hangs when threads detached - c++

Question

I wrote this code to test some behaviour of boost asio together with detached threads.
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <iostream>
#include <string>
#include <thread>
class printer {
public:
printer(boost::asio::io_service &io)
: timer_(io, boost::posix_time::seconds(1)), count_(0) {
timer_.async_wait(boost::bind(&printer::print, this));
}
~printer() { std::cout << "Final count is " << count_ << "\n"; }
void print() {
if (count_ < 10) {
std::cout << "thread " << std::this_thread::get_id()
<< ", count = " << count_ << std::endl;
++count_;
timer_.expires_at(timer_.expires_at() + boost::posix_time::seconds(1));
timer_.async_wait(boost::bind(&printer::print, this));
}
}
private:
boost::asio::deadline_timer timer_;
int count_;
};
boost::asio::io_service io;
int main() {
boost::asio::io_service::work work(io);
std::cout << "main thread " << std::this_thread::get_id() << std::endl;
std::thread t([] { io.run(); });
std::thread t2([] { io.run(); });
t.detach();
t2.detach();
printer p(io);
std::string name;
std::cout << "Press a key";
std::getline(std::cin, name);
std::cout << "finished" << std::endl;
return 0;
}
I wanted to see what happens when I have two worker threads, running io_service.run method, and what happens when they are detached (especially what happens when program exits).
The first problem is that when I run this program on linux I can see only one thread id when in Printer. Somehow the second thread does not take the task from io_service, even though it should, as it is running io_service.run method.
The second problem I see is that sometimes when I press ENTER before all 10 printouts from Printer are made, the program exits normally, and sometimes not (console hangs). Why is that?
What am I doing wrong here?

Answer 1

The main problem in your code is that the printer get called even after its destruction: the threads are detached, so they might be running even when the main function is ended and the printer is destroyed. With this issue it is not possible to have a defined behaviour, since the threads still might work with the printer that is destroyed. The hanging sometimes happens sometimes not - undefined behavior. Why this happens hard to say specifically. What is obvious here is that the threads are working with garbage data.
Summing up the flaws:
There is a possibility for the printer instance to be used even after destruction;
There is a possibility for the io_service instance to be used even after destruction: the threads' labmdas are holding references and the run method might still be in the process of execution while the objects are destroyed (there is no any guaranties on the relative order of static variable destruction and the detached thread terminations, as well as boost::asio::io_service does not block the destructor for the run method to be finished).
My suggestion is to introduced a defined order of destruction. Unfortunately, you cannot just say: ok, I am done, threads are detached, I quit. Because there is still work going on in the threads, but the relevant objects are destroyed.
class printer {
public:
printer(boost::asio::io_service& io)
: timer_(io, boost::posix_time::seconds(1)), count_(0) {
timer_.async_wait(
boost::bind(&printer::print, this));
}
~printer() { std::cout << "Final count is " << count_ << "\n"; }
void print() {
if (count_ < 10) {
std::cout << "thread " << std::this_thread::get_id() << ", count = " << count_
<< std::endl;
++count_;
timer_.expires_at(timer_.expires_at() + boost::posix_time::seconds(1));
timer_.async_wait(
boost::bind(&printer::print, this));
}
}
boost::asio::deadline_timer timer_;
int count_;
};
boost::asio::io_service io;
int main() {
auto work = std::unique_ptr<boost::asio::io_service::work>(
new boost::asio::io_service::work(io));
std::cout << "main thread " << std::this_thread::get_id() << std::endl;
std::thread t([&] { io.run(); });
std::thread t2([&] { io.run(); });
printer p(io);
std::string name;
std::cout << "Press a key";
std::getline(std::cin, name);
work.reset();
io.stop();
t.join();
t2.join();
std::cout << "finished" << std::endl;
return 0;
}

Answer 2

The result of the program depends on the order in which the two detached threads are executed. It's possible that sometimes they both start running after the main program has finished, and therefore the io object has already been destroyed.
You should try to force them to run before the main program exits, either by making them joinable or, if you really want to try them as detached, by adding a sleep before the program exits.