Создание таймеров с boost :: asio :: thread_pool

Question

Я пытаюсь создать таймеры, используя усиление "thread_pool".

Я уже нашел примеры того, как сделать это, используя «thread_group» с «io_service», но я не понимаю, как я могу использовать «boost :: asio :: high_resolution_timer» с «thread_pool», например.

В следующем коде я могу создать пул потоков, используя "io_service" и "thread_group":

#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <boost/smart_ptr.hpp>
#include <boost/bind.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>

using namespace std;
using namespace boost;
using namespace boost::asio;

class IoServiceThreadPool : 
    public boost::enable_shared_from_this <IoServiceThreadPool>{

    int pool_size;
    int stack_size;
    boost::shared_ptr<io_service> service;
    boost::thread_group threads;
    boost::scoped_ptr<io_service::work> work;

public:
    IoServiceThreadPool(unsigned int pool_size_, unsigned int stack_size_) :
        pool_size(pool_size_),
        stack_size(stack_size_),
        service(new io_service(pool_size_)),
        threads(),
        work()
    {
    }

    void init()
    {
        thread_attributes attributes;
        attributes.set_stack_size(stack_size);
        work.reset(new io_service::work(*service.get()));
        for (unsigned int i = 0; i < pool_size; i++)
        {
            threads.add_thread(
                new boost::thread(
                    attributes,
                    boost::bind(&IoServiceThreadPool::run, shared_from_this())));
        }
    }

    void run()
    {
        bool mustContinue(true);
        do {
            try {
                boost::system::error_code ec;
                service->run(ec);
                mustContinue = false;
                break;
            }
            catch (...) {
                mustContinue = true;
            }
        } while (mustContinue);
    }

    boost::shared_ptr<io_service> getIoService()
    {
        return service;
    }
};

И мой таймер выглядит следующим образом:

class MyTimer :
    public boost::enable_shared_from_this<MyTimer> {

    boost::asio::high_resolution_timer timer;
    std::chrono::milliseconds interval;

public:
    MyTimer(io_service & service_, unsigned long interval_) :
        timer(service_),
        interval(interval_)
    {
        timer.expires_at(
            boost::asio::high_resolution_timer::clock_type::now());
    }

    void start() 
    {
        timer.expires_at(
            boost::asio::high_resolution_timer::clock_type::now()
            + interval);
        timer.async_wait(boost::bind(
            &MyTimer::timeoutCallback,
            shared_from_this(),
            boost::asio::placeholders::error));
    }

    void timeoutCallback(const boost::system::error_code& error)
    {
        cout << "Timer called!" << endl;
    }
};

Чтобы активировать мой таймер через 2 секунды:

boost::shared_ptr<IoServiceThreadPool> ioService(
    boost::make_shared<IoServiceThreadPool>(4, 256 * 1024)
);
ioService->init();

boost::shared_ptr<MyTimer> timer(
    boost::make_shared<MyTimer>(*(ioService->getIoService()), 2000)
);
timer->start();

Но я бы хотел использовать «boost :: asio :: thread_pool» со ​​следующим кодом:

class Job {

public:
    virtual ~Job() {}
    virtual void runJob() = 0;
};

class Pool {
public:
    boost::asio::thread_pool pool;

    Pool(int size) :
        pool(size) { }
    ~Pool() { }

    void post(boost::shared_ptr<Job> const& job)
    {
        boost::asio::post(pool,
            boost::bind(&Job::runJob, job));
    }

    void join()
    {
        pool.join();
    }
};

Возможно ли это?

Документы: boost :: asio :: thread_pool