I'm trying to figure out why a call to boost::io_service::post might be failing. My program is multithreaded, and has a periodic "timing event" that is triggered. The timing event calls "Service.post(&OnSignal);" to execute a handler, while another thread runs the service. Using this design, I can post an event from any thread without worrying about explicit resource locking.

My question is, why does my call to Service.post always fail? I know it is failing because the function that I post never gets called. There is not explicit return code or thrown exception to indicate that there is a problem.

Below is an example of what I'm trying to do. Inside main(), there is a commented call to "Service.post(&OnSignal);". Uncommenting that line results in a successful post to the Service, which eventually calls OnSignal, (but only once, obviously). Why does that call work, but not the call in TimingSignalThread()?

#include <iostream>
#include <boost/asio.hpp>
#include <boost/thread/thread.hpp>
using namespace std;

// This is the service responsible for queuing the events.
boost::asio::io_service Service;

// This is the function that should be periodically queued by the TimingSignalThread.
void OnSignal()
{
    cout << "Got timing signal";
}

// This function runs in its own thread, and periodically posts OnSignal() to the Service.
void TimingSignalThread()
{
    boost::this_thread::disable_interruption di;
    // Run until interrupted by <enter>.
    while(!boost::this_thread::interruption_requested())
    {
        cout << ".";
        boost::this_thread::sleep(boost::posix_time::millisec(500));
        Service.post(&OnSignal); // This post is never successful.
    }
}

// This function runs in its own thread, and executes all posts.
void ServiceRunner()
{
    Service.run();
}

int main()
{
    boost::thread TimingThread(&TimingSignalThread);
    boost::thread ServiceThread(&ServiceRunner);
//    Why does 'post()' work here, but not in TimingSignalThread()?
//    Uncommenting the following line results in a single successful post to OnSignal.
//    Service.post(&OnSignal);
    cin.get(); // Press enter to end the program.
    TimingThread.interrupt();
    TimingThread.join();
    Service.stop();
    ServiceThread.join();
    cout << "Joined all threads." << endl;
    return 0;
}