So I got myself a threadpool-task manager system. Should I from now on use only it for all threads creation?

So I have a thread pool that allows dynamic resizing and uses task paradigm. I wonder - when people get such thing do they stop creating threads by hand at all and just use tasks all the time? So is it common to use only thread-pool\task-executor for threads creation inside of my class?

my thread pool is based on boost::asio::io_service and works with boost::packaged_task.it is header only, having boost 1.47.0 all you need for it to work are timer, my costume thread_group and the thread_pool class. It was quite fun to develop such small thing but now I stand behind a dilemma.

my task constructions look like:

boost::shared_ptr< boost::packaged_task<int> > task(new boost::packaged_task<int>( boost::bind(calculate_the_answer_to_life_the_universe_and_everything, argument_int_value  )));

this is quite over head in case when I want create a function that would newer return anything, would have in it some run again timer (for example files indexer that needs to check every 5 seconds if user has created any new file in some folder)

so for example I would have:

void infinite_thread()
{
    while(true)
    {
    timerForCaptureFame.restart();
    do_stuff();
    spendedTimeForCaptureFame = (int64_t)timerForCaptureFame.elapsed();
    if (spendedTimeForCaptureFame < desiredTimeForCaptureFame)
        boost::this_thread::sleep(boost::posix_time::milliseconds(desiredTimeForCaptureFame - spendedTimeForCaptureFame));
    }
}

and I would simply create this wraper into new thread with code like

boost::thread workerThread(infinite_thread);

But now I can have tasks so it could turn into

boost::shared_ptr< boost::packaged_task<void> > task(new boost::packaged_task<void>(infinite_thread));
task_manager->post<void>(task);

My task manager after some small amount of time would get that thread does not close itself and will generally add to itself new thread for execution keeping this one working.

So I really wonder if it is common practice having a thread_pool/task_pool to use only it (for example one per class) for threads creation or people mix there tasks wi开发者_开发知识库th "pure" threads?

There is no clear answer. There might be things that seem better suited for regular threads and don't quite fit the task paradigm, for example threads that need to last for the whole duration of the program, or that might outlive the thread pool. If it is never going to be taken back to the pool, then you might as well handle it as a separate thing.

Then again, since you already have the thread pool, you might want to just force all threads to be tasks even if they are infinitely long tasks... but beware of the law of the instrument. It might seem that every job is a task/nail to your new pool/golden hammer.