[Boost-users] async processing issues

Subject: [Boost-users] async processing issues
From: SRD (software.research.development_at_[hidden])
Date: 2013-07-02 23:45:10

Having a tough time learning ASIO. I'm trying to have one thread constantly
listen for new file monitoring events (mthread) while another thread
processes one task at a time (wthread). Somehow I'm still losing events
that don't get placed on the task_queue and it would seem that once an
event is lost, the file_handler callback for the dir_monitor stops working
thereafter for good. So I'm having a few issues with my solution.

If I comment out the sleep() method below, then for some reason the first
two lines that have to do with the dir_monitor immediately after the while
loop quickly eat through all available memory and the program will soon
crash within a minute or two. Leaving the sleep in keeps things stable, or
maybe it just eats away so slowly I don't notice it.

Leaving sleep() in also has the problem of *I think* causing missed file
events. The f_handler() function posts tasks that I create within the
dir_monitor callback back to the main thread via the io_service.post(), but
if its asleep, will it be able to place objects on the main processes
task_queue? I think thats one point where I'm going wrong.

If anyone sees where I'm going wrong, any help much appreciated.

---
static queue<TaskObj *> task_queue;
boost::asio::io_service io_service;
void queue_task(TaskObj *task)
{
    // pass task back to main thread.
    task_queue.push(task);
}
void f_handler(const boost::system::error_code &ec, const
boost::asio::dir_monitor_event &ev)
{
    TaskObj task = new TaskObj(...);
    // create task and place on queue by posting to main process
    io_service.post(boost::bind(queue_task, task));
}
int main(...) {
    boost::asio::io_service work_service;
    boost::asio::dir_monitor dm(io_service);
    dm.async_monitor(f_handler);
    // dir_monitor thread
    boost::thread mthread =
        boost::thread(boost::bind(&boost::asio::io_service::run,
        boost::ref(io_service)));
    // setup work to prevent premature exit
    shared_ptr<boost::asio::io_service::work>
        work(new boost::asio::io_service::work(work_service));
    // worker thread
    boost::thread wthread(boost::bind(&boost::asio::io_service::run,
        boost::ref(work_service)));
    wthread.detach();
    while (true) {
        io_service.reset();
        dm.async_monitor(f_handler);
        // losing all available memory from above two lines without the
sleep() below
        // get first task off of queue and process in worker thread
        task = task_queue.front();
        // functor executed in seperate thread
        work_service.post(boost::bind(&TaskObj::do_it, task));
        sleep(3);
    }