Boost asio 多线程应用序列化定时器回调

你正在你的处理程序中做一个。这将阻塞服务线程，干扰调度。sleep(60)

无论如何，我无法重现该问题。在此过程中添加一些测量值（并减少时间间隔以更好地适应我的耐心水平）：

Live On Coliru（科里鲁生活公寓）

#include <boost/asio.hpp>
#include <iostream>
#include <iomanip>

namespace asio = boost::asio;
using namespace std::chrono_literals;
using boost::system::error_code;

static std::atomic_int tid_gen = 0;
thread_local int const tid     = [] { return ++tid_gen; }();
static constexpr auto  now = std::chrono::steady_clock::now;
static auto const      start   = now();
static std::mutex console_mx;

void trace(auto const&... msg) {
    std::lock_guard lk(console_mx);
    std::cerr << "at " << std::setw(8) << (now() - start)/1ms << "ms - tid:" << tid << " ";
    (std::cerr << ... << msg) << std::endl;
}

void worker(asio::io_context& ioContext) {
    trace("Worker thread enter");
    ioContext.run(); // Run the io_context to handle asynchronous operations
    trace("Worker thread exit");
}

int main() {
    try {
        asio::io_context ioContext;

        // Create a work object to prevent ioContext.run() from returning immediately
        auto work = make_work_guard(ioContext);

        // Create multiple worker threads
        std::vector<std::thread> threads;
        for (int i = 0; i < 2; ++i) {
            threads.emplace_back(worker, std::ref(ioContext));
        }

        asio::steady_timer task1(ioContext, 50ms);
        asio::steady_timer task2(ioContext, 100ms);

        task1.async_wait([](error_code ec) {
            trace("Start Task1: ", ec.message());
            if (!ec)
                sleep(6);
        });

        task2.async_wait([](error_code ec) { trace("Start Task2: ", ec.message()); });

        trace("App started :", std::thread::hardware_concurrency());

        work.reset();
        // Join the worker threads
        for (auto& thread : threads) {
            thread.join();
        }

        trace("All worker threads joined.");
    } catch (std::exception const& e) {
        trace("Exception: ", std::quoted(e.what()));
    }
}

印刷

at        0ms - tid:1 Worker thread enter
at        0ms - tid:2 Worker thread enter
at        0ms - tid:3 App started :4
at       50ms - tid:1 Start Task1: Success
at      100ms - tid:2 Start Task2: Success
at     6050ms - tid:1 Worker thread exit
at     6050ms - tid:2 Worker thread exit
at     6050ms - tid:3 All worker threads joined.

这正是我所期望的

旁注：使用并实际获得一个基于硬件并发性自动调整大小的池，取消工作防护和其他简化：thread_pool

Live On Coliru（科里鲁生活公寓）

#include <boost/asio.hpp>
#include <iostream>
#include <iomanip>

namespace asio = boost::asio;
using namespace std::chrono_literals;
using namespace std::placeholders;
using boost::system::error_code;

static std::atomic_int tid_gen = 0;
thread_local int const tid     = [] { return ++tid_gen; }();

using duration = std::chrono::steady_clock::duration;
static constexpr auto now   = std::chrono::steady_clock::now;
static auto const     start = now();
static std::mutex     console_mx;

void trace(auto const&... msg) {
    std::lock_guard lk(console_mx);
    std::cerr << "at " << std::setw(8) << (now() - start) / 1ms << "ms - tid:" << tid << " ";
    (std::cerr << ... << msg) << std::endl;
}

void do_task(error_code ec, std::string caption, duration block_for = {}) {
    trace("Start ", caption, ": ", ec.message());
    if (!ec)
        std::this_thread::sleep_for(block_for);
}

int main() {
    asio::thread_pool io;

    asio::steady_timer task1(io, 50ms);
    asio::steady_timer task2(io, 100ms);

    task1.async_wait(bind(do_task, _1, "Task1", 6s));
    task2.async_wait(bind(do_task, _1, "Task2", 0s));

    trace("App started: ", std::thread::hardware_concurrency());

    io.join();
    trace("Done");
}

指纹

at        0ms - tid:1 App started: 4
at       50ms - tid:2 Start Task1: Success
at      100ms - tid:3 Start Task2: Success
at     6051ms - tid:1 Done