Use boost thread_pool with boost steady_timer

I want to use execute a timer-based task with a pool of threads. I wrote the following code:

boost::asio::thread_pool thread_pool{};
boost::asio::steady_timer timer{thread_pool.get_executor(), std::chrono::seconds{1}};
timer.async_wait([](const boost::system::error_code&){
     std::cout << "Task Completed" << std::endl;
});

Is this the correct way to achieve this? or should I be using an io_context and then run that in every thread of thread_group? From what I can find online is that io_context should be used for any io including timer-related tasks but then why does the above code compile with thread_pool? Since one can argue that using thread_pool provides a cleaner outlook is there any place I should use io_context?

> Is this the correct way to achieve this?

It is one correct way that can work

> or should I be using an io_context and then run that in every thread
> of thread_group?

You should not. Basically for the reason that it is almost exactly the same thing, but less correct. With your own thread-groups you have to do work to maintain fair scheduling and handle exceptions correctly.

> Since one can argue that using thread_pool provides a cleaner outlook is there any place I should use io_context?

Good point actually. You should use io_context when you don't want threads. Sometimes your platform doesn't support thread creation, thread scheduling introduces non-determinism you want to avoid, or you just don't want to have any synchronization issues even regarding globals. E.g.

int main() {
   io_context ioc(1);
   start_server(ioc);
   ioc.run(); // main thread
}

Is conceptually similar to

int main() {
   thread_pool ioc(1);
   start_server(ioc);
   ioc.join(); // separate thread
}

I liberally write the latter, also because it can reduce the need for work-guards (thread_pool hold an executor work guard internally).