Replace per-operation thread spawning with shared thread pool

Resolver operations previously created and detached a new std::thread
for every blocking getaddrinfo()/getnameinfo() call. Add a generic
detail::thread_pool execution_context service that reuses threads
across operations, and wire both POSIX and Windows resolver services
to dispatch blocking work through it.

Author: sgerbino

include/boost/corosio/detail/thread_pool.hpp

@@ -0,0 +1,160 @@
+//
+// Copyright (c) 2026 Steve Gerbino
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Official repository: https://github.com/cppalliance/corosio
+//
+
+#ifndef BOOST_COROSIO_DETAIL_THREAD_POOL_HPP
+#define BOOST_COROSIO_DETAIL_THREAD_POOL_HPP
+
+#include <boost/corosio/detail/config.hpp>
+#include <boost/capy/ex/execution_context.hpp>
+
+#include <condition_variable>
+#include <deque>
+#include <functional>
+#include <mutex>
+#include <thread>
+#include <vector>
+
+namespace boost::corosio::detail {
+
+/** Shared thread pool for dispatching blocking operations.
+
+    Provides a fixed pool of reusable worker threads for operations
+    that cannot be integrated with async I/O (e.g. blocking DNS
+    calls). Registered as an `execution_context::service` so it
+    is a singleton per io_context.
+
+    Threads are created lazily on the first `post()` call. The
+    default thread count is 1.
+
+    @par Thread Safety
+    All public member functions are thread-safe.
+
+    @par Shutdown
+    Sets a shutdown flag, notifies all threads, and joins them.
+    In-flight blocking calls complete naturally before the thread
+    exits.
+*/
+class thread_pool final
+    : public capy::execution_context::service
+{
+    std::mutex mutex_;
+    std::condition_variable cv_;
+    std::deque<std::function<void()>> work_queue_;
+    std::vector<std::thread> threads_;
+    bool shutdown_ = false;
+    bool started_ = false;
+    unsigned num_threads_;
+
+    void start_threads();
+    void worker_loop();
+
+public:
+    using key_type = thread_pool;
+
+    /** Construct the thread pool service.
+
+        @param ctx Reference to the owning execution_context.
+        @param num_threads Number of worker threads (default 1).
+    */
+    explicit thread_pool(
+        capy::execution_context& ctx,
+        unsigned num_threads = 1)
+        : num_threads_(num_threads)
+    {
+        (void)ctx;
+    }
+
+    ~thread_pool() override = default;
+
+    thread_pool(thread_pool const&) = delete;
+    thread_pool& operator=(thread_pool const&) = delete;
+
+    /** Enqueue a work item for execution on the thread pool.
+
+        Starts threads lazily on the first call.
+
+        @param f The callable to execute.
+    */
+    void post(std::function<void()> f);
+
+    /** Shut down the thread pool.
+
+        Signals all threads to exit after draining any
+        remaining queued work, then joins them.
+    */
+    void shutdown() override;
+};
+
+inline void
+thread_pool::start_threads()
+{
+    threads_.reserve(num_threads_);
+    for (unsigned i = 0; i < num_threads_; ++i)
+        threads_.emplace_back([this] { worker_loop(); });
+    started_ = true;
+}
+
+inline void
+thread_pool::worker_loop()
+{
+    for (;;)
+    {
+        std::function<void()> task;
+        {
+            std::unique_lock<std::mutex> lock(mutex_);
+            cv_.wait(lock, [this] {
+                return shutdown_ || !work_queue_.empty();
+            });
+
+            if (work_queue_.empty())
+            {
+                if (shutdown_)
+                    return;
+                continue;
+            }
+
+            task = std::move(work_queue_.front());
+            work_queue_.pop_front();
+        }
+        task();
+    }
+}
+
+inline void
+thread_pool::post(std::function<void()> f)
+{
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        if (!started_)
+            start_threads();
+        work_queue_.push_back(std::move(f));
+    }
+    cv_.notify_one();
+}
+
+inline void
+thread_pool::shutdown()
+{
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        shutdown_ = true;
+    }
+    cv_.notify_all();
+
+    for (auto& t : threads_)
+    {
+        if (t.joinable())
+            t.join();
+    }
+    threads_.clear();
+}
+
+} // namespace boost::corosio::detail
+
+#endif // BOOST_COROSIO_DETAIL_THREAD_POOL_HPP

include/boost/corosio/native/detail/iocp/win_resolver.hpp

@@ -42,12 +42,9 @@
 #include <WS2tcpip.h>
 
 #include <atomic>
-#include <condition_variable>
 #include <cstring>
 #include <memory>
 #include <string>
-#include <thread>
-#include <unordered_map>
 
 // MinGW may not have GetAddrInfoExCancel declared
 #if defined(__MINGW32__) || defined(__MINGW64__)
@@ -72,30 +69,28 @@ extern "C"
     Reverse Resolution (GetNameInfoW)
     ---------------------------------
     Unlike GetAddrInfoExW, GetNameInfoW has no async variant. Reverse
-    resolution spawns a detached worker thread that calls GetNameInfoW
-    and posts the result to the scheduler upon completion.
+    resolution dispatches the blocking call to the shared
+    resolver_thread_pool service.
 
     Class Hierarchy
     ---------------
     - win_resolver_service (execution_context::service)
         - Owns all win_resolver instances via shared_ptr
         - Coordinates with win_scheduler for work tracking
-        - Tracks active worker threads for safe shutdown
     - win_resolver (one per resolver object)
         - Contains embedded resolve_op and reverse_resolve_op
         - Inherits from enable_shared_from_this for thread safety
     - resolve_op (overlapped_op subclass)
         - OVERLAPPED base enables IOCP integration
         - Static completion() callback invoked by Windows
     - reverse_resolve_op (overlapped_op subclass)
-        - Used by worker thread for reverse resolution
+        - Used by pool thread for reverse resolution
 
-    Shutdown Synchronization
-    ------------------------
-    The service uses condition_variable_any and win_mutex to track active
-    worker threads. During shutdown(), the service waits for all threads
-    to complete before destroying resources. Worker threads always post
-    their completions so the scheduler can properly drain them via destroy().
+    Shutdown
+    --------
+    The resolver service cancels all resolvers and clears the impl map.
+    The thread pool service shuts down separately via execution_context
+    service ordering, joining all worker threads.
 
     Cancellation
     ------------
@@ -128,17 +123,14 @@ extern "C"
 
     Reverse Resolution (GetNameInfoW)
     ---------------------------------
-    Unlike GetAddrInfoExW, GetNameInfoW has no async variant. We use a worker
-    thread approach similar to POSIX:
-    1. reverse_resolve() spawns a detached worker thread
-    2. Worker calls GetNameInfoW() (blocking)
-    3. Worker converts wide results to UTF-8 via WideCharToMultiByte
-    4. Worker posts completion to scheduler
+    Unlike GetAddrInfoExW, GetNameInfoW has no async variant. The blocking
+    call is dispatched to the shared resolver_thread_pool:
+    1. reverse_resolve() posts work to the thread pool
+    2. Pool thread calls GetNameInfoW() (blocking)
+    3. Pool thread converts wide results to UTF-8 via WideCharToMultiByte
+    4. Pool thread posts completion to scheduler
     5. op_() resumes the coroutine with results
 
-    Thread tracking (thread_started/thread_finished) ensures safe shutdown
-    by waiting for all worker threads before destroying the service.
-
     String Conversion
     -----------------
     Windows APIs require wide strings. We use MultiByteToWideChar for