第 19.1.1 節

定時器與異步 IO

0瀏覽次數0訪問次數--跳出率--平均停留

本節是整套 Boost.Asio 教程最重要的一節。
串口、TCP、UDP 的異步模型都和定時器類似：先註冊異步操作，然後由 io_context.run() 驅動回調執行。

本節所有異步回調都使用 std::bind，暫時不使用 lambda。

示例 1：普通 main() 裡寫同步定時器

程序目標

先寫最簡單的阻塞式定時器：程序啟動後立刻打印一句話，然後阻塞等待 2 秒，再打印結束。

完整代碼

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

int main()
{
    // 程序从 main 函数开始执行，下面的语句会按顺序运行。
    // io_context 是 Asio 的事件循环对象，异步任务需要靠它调度。
    boost::asio::io_context io;

    // 创建定时器，并设置到期时间。
    boost::asio::steady_timer timer(io, std::chrono::seconds(2));

    std::cout << "程序开始：准备等待 2 秒" << std::endl;

    // 同步等待会阻塞当前线程，时间没到之前不会继续往下执行。
    timer.wait();

    std::cout << "2 秒到了：timer.wait() 返回" << std::endl;

    return 0;
}

運行結果：見下方“運行輸出與時間順序”；如果示例涉及定時器、線程、網絡或外部設備，具體時間和順序可能會隨環境略有變化。

編譯運行

g++ demo1_sync_timer.cpp -o demo1_sync_timer -std=c++17 -lboost_system -pthread
./demo1_sync_timer

運行輸出與時間順序

程序开始：准备等待 2 秒

等待約 2 秒後：

2 秒到了：timer.wait() 返回

完整輸出類似：

程序开始：准备等待 2 秒
2 秒到了：timer.wait() 返回

本示例需要注意的點

這個程序沒有體現“異步”，因為 timer.wait() 會直接阻塞當前線程。

也就是說，程序卡在這裡：

timer.wait();

2 秒沒有到之前，下一行不會執行。

關鍵函數說明

boost::asio::io_context io;

作用：創建一個 Asio 事件循環對象。

在同步 wait() 示例中，它看起來沒什麼存在感；但到了異步版本，所有異步事件都要靠它驅動。

boost::asio::steady_timer timer(io, std::chrono::seconds(2));

作用：創建一個基於穩定時鐘的定時器，設置 2 秒後到期。

參數：

io

表示這個 timer 歸哪個 io_context 管。

std::chrono::seconds(2)

表示相對當前時間 2 秒後到期。

timer.wait();

作用：阻塞等待 timer 到期。

返回值：void。

特點：簡單，但是會阻塞當前線程。機器人程序裡如果在主控制循環裡這麼寫，很容易卡住整個程序。

示例 2：普通 main() 裡寫異步定時器

程序目標

把示例 1 改成異步寫法：

  1. 註冊一個 2 秒定時器；
  2. async_wait() 不阻塞；
  3. io.run() 開始阻塞；
  4. 2 秒後回調函數被執行；
  5. 沒有任務後 io.run() 返回。

完整代碼

#include <boost/asio.hpp>
#include <boost/system/error_code.hpp>
#include <chrono>
#include <functional>
#include <iostream>

void on_timer(const boost::system::error_code& ec)
{
    if (ec)
    {
        std::cout << "定时器被取消，错误信息：" << ec.message() << std::endl;
        return;
    }

    std::cout << "回调函数 on_timer：2 秒到了" << std::endl;
}

int main()
{
    // 程序从 main 函数开始执行，下面的语句会按顺序运行。
    // io_context 是 Asio 的事件循环对象，异步任务需要靠它调度。
    boost::asio::io_context io;

    // 创建定时器，并设置到期时间。
    boost::asio::steady_timer timer(io, std::chrono::seconds(2));

    std::cout << "main：注册 async_wait" << std::endl;

    // 注册异步等待：这一行不会阻塞，回调会在定时器到期后执行。
    timer.async_wait(std::bind(on_timer, std::placeholders::_1));

    std::cout << "main：async_wait 已经返回，但回调还没执行" << std::endl;
    std::cout << "main：准备调用 io.run()" << std::endl;

    io.run();

    std::cout << "main：io.run() 返回，程序结束" << std::endl;

    return 0;
}

運行結果：見下方“運行輸出與時間順序”；如果示例涉及定時器、線程、網絡或外部設備，具體時間和順序可能會隨環境略有變化。

編譯運行

g++ demo2_async_timer.cpp -o demo2_async_timer -std=c++17 -lboost_system -pthread
./demo2_async_timer

運行輸出與時間順序

程序立刻輸出：

main：注册 async_wait
main：async_wait 已经返回，但回调还没执行
main：准备调用 io.run()

然後程序會卡在：

io.run();

等待約 2 秒後輸出：

回调函数 on_timer：2 秒到了
main：io.run() 返回，程序结束

完整輸出類似：

main：注册 async_wait
main：async_wait 已经返回，但回调还没执行
main：准备调用 io.run()
回调函数 on_timer：2 秒到了
main：io.run() 返回，程序结束

本示例需要注意的點

async_wait() 不會等待 2 秒。它只是把“2 秒後執行回調”這件事註冊到 io_context 裡。

真正等待的是：

io.run();

所以不要把 async_wait() 理解成“異步版本的 wait”。更準確地說：

async_wait() = 注册任务
io.run() = 执行事件循环
on_timer() = 任务完成后的回调

std::bind 說明

這句代碼：

timer.async_wait(std::bind(on_timer, std::placeholders::_1));

意思是：

当 timer 到期后，Boost.Asio 会传入一个 error_code。
这个 error_code 会填到 std::placeholders::_1 的位置。
最后调用 on_timer(ec)。

on_timer 的函數簽名必須能接收這個參數：

void on_timer(const boost::system::error_code& ec)

關鍵函數說明

timer.async_wait(handler)

作用：註冊一個異步等待操作。

參數：一個回調函數對象。

返回值：void。

注意：它不會阻塞等待定時器到期。

io.run()

作用：啟動事件循環，處理異步任務和回調函數。

返回值：執行過的 handler 數量，類型通常可以看成 std::size_t。

本例中，io.run() 執行了 1 個回調，所以返回值是 1。只是我們沒有打印返回值。

示例 3：普通 main() 裡寫兩個異步定時器

程序目標

一個 timer 很難看出異步調度的感覺，所以這次寫兩個 timer：

  1. timer1 1 秒後到期；
  2. timer2 3 秒後到期；
  3. 兩個 timer 都在同一個 io_context 裡；
  4. io.run() 會等兩個任務都完成後才返回。

完整代碼

#include <boost/asio.hpp>
#include <boost/system/error_code.hpp>
#include <chrono>
#include <functional>
#include <iostream>
#include <string>

void on_timer(const boost::system::error_code& ec, const std::string& name)
{
    if (ec)
    {
        std::cout << name << " 被取消：" << ec.message() << std::endl;
        return;
    }

    std::cout << name << " 到期，执行回调" << std::endl;
}

int main()
{
    // 程序从 main 函数开始执行，下面的语句会按顺序运行。
    // io_context 是 Asio 的事件循环对象，异步任务需要靠它调度。
    boost::asio::io_context io;

    // 创建定时器，并设置到期时间。
    boost::asio::steady_timer timer1(io, std::chrono::seconds(1));
    boost::asio::steady_timer timer2(io, std::chrono::seconds(3));

    std::cout << "main：注册 timer1，1 秒后到期" << std::endl;
    // 注册异步等待：这一行不会阻塞，回调会在定时器到期后执行。
    timer1.async_wait(std::bind(on_timer,
                                std::placeholders::_1,
                                std::string("timer1")));

    std::cout << "main：注册 timer2，3 秒后到期" << std::endl;
    timer2.async_wait(std::bind(on_timer,
                                std::placeholders::_1,
                                std::string("timer2")));

    std::cout << "main：调用 io.run()" << std::endl;

    std::size_t count = io.run();

    std::cout << "main：io.run() 返回，一共执行了 " << count << " 个回调" << std::endl;

    return 0;
}

運行結果：見下方“運行輸出與時間順序”；如果示例涉及定時器、線程、網絡或外部設備，具體時間和順序可能會隨環境略有變化。

編譯運行

g++ demo3_two_timers.cpp -o demo3_two_timers -std=c++17 -lboost_system -pthread
./demo3_two_timers

運行輸出與時間順序

程序立刻輸出：

main：注册 timer1，1 秒后到期
main：注册 timer2，3 秒后到期
main：调用 io.run()

約 1 秒後輸出：

timer1 到期，执行回调

再過約 2 秒，也就是程序啟動後約 3 秒，輸出：

timer2 到期，执行回调
main：io.run() 返回，一共执行了 2 个回调

完整輸出類似：

main：注册 timer1，1 秒后到期
main：注册 timer2，3 秒后到期
main：调用 io.run()
timer1 到期，执行回调
timer2 到期，执行回调
main：io.run() 返回，一共执行了 2 个回调

本示例需要注意的點

兩個 timer 不是兩個線程。

本例只有一個線程，也就是主線程。timer1 和 timer2 的回調都在調用 io.run() 的這個主線程裡執行。

真正的執行順序是：

主线程进入 io.run()
等待事件
timer1 先到期 -> 调用 timer1 回调
继续等待事件
timer2 后到期 -> 调用 timer2 回调
没有任务了 -> io.run() 返回

std::bind 裡的固定參數

這句：

std::bind(on_timer, std::placeholders::_1, std::string("timer1"))

等價於提前準備了一個函數對象：

未来 Asio 传入 ec 时，调用 on_timer(ec, "timer1")。

_1 是未來由 Asio 傳入的錯誤碼。

"timer1" 是現在就固定好的參數。

示例 4：普通 main() 裡寫重複定時器

程序目標

實現一個每 1 秒打印一次的定時器，打印 5 次後結束。

這個例子很像機器人裡的週期任務，例如：

每 20ms 发送一次速度命令
每 100ms 检查一次下位机心跳
每 1s 打印一次通信状态

完整代碼

#include <boost/asio.hpp>
#include <boost/system/error_code.hpp>
#include <chrono>
#include <functional>
#include <iostream>

void repeat_timer(const boost::system::error_code& ec,
                  boost::asio::steady_timer* timer,
                  int* count)
{
    if (ec)
    {
        std::cout << "repeat_timer 被取消：" << ec.message() << std::endl;
        return;
    }

    ++(*count);
    std::cout << "第 " << *count << " 次定时器回调" << std::endl;

    if (*count < 5)
    {
        timer->expires_after(std::chrono::seconds(1));
        timer->async_wait(std::bind(repeat_timer,
                                    std::placeholders::_1,
                                    timer,
                                    count));
    }
    else
    {
        std::cout << "已经执行 5 次，不再重新注册定时器" << std::endl;
    }
}

int main()
{
    // 程序从 main 函数开始执行，下面的语句会按顺序运行。
    // io_context 是 Asio 的事件循环对象，异步任务需要靠它调度。
    boost::asio::io_context io;
    // 创建定时器，并设置到期时间。
    boost::asio::steady_timer timer(io, std::chrono::seconds(1));
    int count = 0;

    std::cout << "main：注册第 1 次定时器" << std::endl;

    // 注册异步等待：这一行不会阻塞，回调会在定时器到期后执行。
    timer.async_wait(std::bind(repeat_timer,
                               std::placeholders::_1,
                               &timer,
                               &count));

    io.run();

    std::cout << "main：io.run() 返回，程序结束" << std::endl;

    return 0;
}

運行結果：見下方“運行輸出與時間順序”；如果示例涉及定時器、線程、網絡或外部設備，具體時間和順序可能會隨環境略有變化。

編譯運行

g++ demo4_repeat_timer.cpp -o demo4_repeat_timer -std=c++17 -lboost_system -pthread
./demo4_repeat_timer

運行輸出與時間順序

程序立刻輸出：

main：注册第 1 次定时器

約 1 秒後：

第 1 次定时器回调

之後每隔約 1 秒輸出一次：

第 2 次定时器回调
第 3 次定时器回调
第 4 次定时器回调
第 5 次定时器回调
已经执行 5 次，不再重新注册定时器
main：io.run() 返回，程序结束

完整輸出類似：

main：注册第 1 次定时器
第 1 次定时器回调
第 2 次定时器回调
第 3 次定时器回调
第 4 次定时器回调
第 5 次定时器回调
已经执行 5 次，不再重新注册定时器
main：io.run() 返回，程序结束

本示例需要注意的點

重複定時器不是 while 循環裡 sleep。

異步寫法是：

第一次 async_wait
第 1 次回调里重新设置 expires_after
第 1 次回调里再次 async_wait
第 2 次回调里再次注册
……

也就是“每次回調結束前，決定要不要註冊下一次”。

指針生命週期說明

本例裡傳了：

&timer
&count

這是為了讓 repeat_timer() 能修改同一個 timer 和 count。

這個寫法在本例中是安全的，因為：

timer 和 count 都是 main() 里的局部变量
main() 会卡在 io.run()
io.run() 返回前，timer 和 count 都不会析构

但是工程裡更推薦把它封裝成類，見下一個示例。

示例 5：類裡寫單個異步定時器

程序目標

把示例 2 改成類封裝版本。

類封裝是機器人項目裡更常見的寫法，例如：

SerialDriver 类
TcpClient 类
UdpReceiver 类
RobotController 类

完整代碼

#include <boost/asio.hpp>
#include <boost/system/error_code.hpp>
#include <chrono>
#include <functional>
#include <iostream>

class Printer
{
public:
    explicit Printer(boost::asio::io_context& io)
        : timer_(io, std::chrono::seconds(2))
    {
        std::cout << "Printer 构造：注册 2 秒定时器" << std::endl;

        // 注册异步等待：这一行不会阻塞，回调会在定时器到期后执行。
        timer_.async_wait(std::bind(&Printer::on_timer,
                                    this,
                                    std::placeholders::_1));
    }

private:
    void on_timer(const boost::system::error_code& ec)
    {
        if (ec)
        {
            std::cout << "Printer::on_timer 被取消：" << ec.message() << std::endl;
            return;
        }

        std::cout << "Printer::on_timer：2 秒到了" << std::endl;
    }

private:
    // 创建定时器，并设置到期时间。
    boost::asio::steady_timer timer_;
};

int main()
{
    // 程序从 main 函数开始执行，下面的语句会按顺序运行。
    // io_context 是 Asio 的事件循环对象，异步任务需要靠它调度。
    boost::asio::io_context io;

    Printer printer(io);

    std::cout << "main：准备调用 io.run()" << std::endl;

    io.run();

    std::cout << "main：io.run() 返回" << std::endl;

    return 0;
}

運行結果：見下方“運行輸出與時間順序”；如果示例涉及定時器、線程、網絡或外部設備，具體時間和順序可能會隨環境略有變化。

編譯運行

g++ demo5_class_timer.cpp -o demo5_class_timer -std=c++17 -lboost_system -pthread
./demo5_class_timer

運行輸出與時間順序

程序立刻輸出：

Printer 构造：注册 2 秒定时器
main：准备调用 io.run()

約 2 秒後輸出：

Printer::on_timer：2 秒到了
main：io.run() 返回

完整輸出類似：

Printer 构造：注册 2 秒定时器
main：准备调用 io.run()
Printer::on_timer：2 秒到了
main：io.run() 返回

構造函數初始化列表說明

這段：

explicit Printer(boost::asio::io_context& io)
    : timer_(io, std::chrono::seconds(2))
{
}

冒號後面叫“構造函數初始化列表”。

它的作用是：在進入構造函數大括號之前，直接構造成員變量 timer_。

為什麼這裡必須這麼寫？因為 boost::asio::steady_timer 沒有一個適合你先默認構造、再賦值的簡單寫法。它需要在構造時就知道自己屬於哪個 io_context。

成員函數綁定說明

這句：

timer_.async_wait(std::bind(&Printer::on_timer,
                            this,
                            std::placeholders::_1));

含義是：

定时器到期后，调用 this->on_timer(ec)。

為什麼要寫 &Printer::on_timer？

因為 on_timer 是成員函數，不是普通全局函數。成員函數必須依賴某個對象才能調用。

為什麼要傳 this？

因為 this 表示當前這個 Printer 對象。

易錯點

不要寫成：

std::bind(on_timer, std::placeholders::_1)

因為 on_timer 是成員函數，不是普通函數。

也不要漏掉 this：

std::bind(&Printer::on_timer, std::placeholders::_1)

這樣不知道要調用哪個對象的 on_timer()。

示例 6：類裡寫兩個定時器

程序目標

類裡同時維護兩個 timer：

  1. timer1_ 1 秒後執行；
  2. timer2_ 3 秒後執行；
  3. 用這個例子看清楚“兩個異步任務不等於兩個線程”。

完整代碼

#include <boost/asio.hpp>
#include <boost/system/error_code.hpp>
#include <chrono>
#include <functional>
#include <iostream>

class TwoTimers
{
public:
    explicit TwoTimers(boost::asio::io_context& io)
        : timer1_(io, std::chrono::seconds(1)),
          timer2_(io, std::chrono::seconds(3))
    {
        std::cout << "TwoTimers 构造：注册 timer1 和 timer2" << std::endl;

        // 注册异步等待：这一行不会阻塞，回调会在定时器到期后执行。
        timer1_.async_wait(std::bind(&TwoTimers::on_timer1,
                                     this,
                                     std::placeholders::_1));

        timer2_.async_wait(std::bind(&TwoTimers::on_timer2,
                                     this,
                                     std::placeholders::_1));
    }

private:
    void on_timer1(const boost::system::error_code& ec)
    {
        if (ec)
        {
            std::cout << "timer1 取消：" << ec.message() << std::endl;
            return;
        }

        std::cout << "timer1：1 秒到了" << std::endl;
    }

    void on_timer2(const boost::system::error_code& ec)
    {
        if (ec)
        {
            std::cout << "timer2 取消：" << ec.message() << std::endl;
            return;
        }

        std::cout << "timer2：3 秒到了" << std::endl;
    }

private:
    // 创建定时器，并设置到期时间。
    boost::asio::steady_timer timer1_;
    boost::asio::steady_timer timer2_;
};

int main()
{
    // 程序从 main 函数开始执行，下面的语句会按顺序运行。
    // io_context 是 Asio 的事件循环对象，异步任务需要靠它调度。
    boost::asio::io_context io;
    TwoTimers app(io);

    std::cout << "main：调用 io.run()" << std::endl;

    io.run();

    std::cout << "main：两个定时器都执行完，io.run() 返回" << std::endl;

    return 0;
}

運行結果：見下方“運行輸出與時間順序”；如果示例涉及定時器、線程、網絡或外部設備，具體時間和順序可能會隨環境略有變化。

編譯運行

g++ demo6_class_two_timers.cpp -o demo6_class_two_timers -std=c++17 -lboost_system -pthread
./demo6_class_two_timers

運行輸出與時間順序

程序立刻輸出：

TwoTimers 构造：注册 timer1 和 timer2
main：调用 io.run()

約 1 秒後：

timer1：1 秒到了

約 3 秒後：

timer2：3 秒到了
main：两个定时器都执行完，io.run() 返回

完整輸出類似：

TwoTimers 构造：注册 timer1 和 timer2
main：调用 io.run()
timer1：1 秒到了
timer2：3 秒到了
main：两个定时器都执行完，io.run() 返回

本示例需要注意的點

timer1_ 和 timer2_ 是兩個異步任務，但本例仍然只有一個線程。

因為只有主線程調用了：

io.run();

所以兩個回調都在主線程裡執行，不會並行執行。

示例 7：兩個線程同時運行同一個 io_context

程序目標

這次讓兩個線程都調用 io.run()，觀察回調可能由不同線程執行。

這個例子用於理解官方 Timer.5 那類程序：

多个线程 run 同一个 io_context
回调函数可能分配给任意一个正在 run 的线程执行

完整代碼

#include <boost/asio.hpp>
#include <boost/system/error_code.hpp>
#include <chrono>
#include <functional>
#include <iostream>
#include <string>
#include <thread>

void print_timer(const boost::system::error_code& ec, const std::string& name)
{
    if (ec)
    {
        std::cout << name << " 取消：" << ec.message() << std::endl;
        return;
    }

    std::cout << name << " 回调执行，线程 id = "
              << std::this_thread::get_id() << std::endl;
}

void run_io(boost::asio::io_context* io, const std::string& thread_name)
{
    std::cout << thread_name << " 开始调用 io.run()，线程 id = "
              << std::this_thread::get_id() << std::endl;

    io->run();

    std::cout << thread_name << " 的 io.run() 返回" << std::endl;
}

int main()
{
    // 程序从 main 函数开始执行，下面的语句会按顺序运行。
    // io_context 是 Asio 的事件循环对象，异步任务需要靠它调度。
    boost::asio::io_context io;

    // 创建定时器，并设置到期时间。
    boost::asio::steady_timer timer1(io, std::chrono::seconds(1));
    boost::asio::steady_timer timer2(io, std::chrono::seconds(1));

    // 注册异步等待：这一行不会阻塞，回调会在定时器到期后执行。
    timer1.async_wait(std::bind(print_timer,
                                std::placeholders::_1,
                                std::string("timer1")));

    timer2.async_wait(std::bind(print_timer,
                                std::placeholders::_1,
                                std::string("timer2")));

    std::thread t1(std::bind(run_io, &io, std::string("线程1")));
    std::thread t2(std::bind(run_io, &io, std::string("线程2")));

    t1.join();
    t2.join();

    std::cout << "main：两个线程都结束" << std::endl;

    return 0;
}

運行結果：見下方“運行輸出與時間順序”；如果示例涉及定時器、線程、網絡或外部設備，具體時間和順序可能會隨環境略有變化。

編譯運行

g++ demo7_two_threads.cpp -o demo7_two_threads -std=c++17 -lboost_system -pthread
./demo7_two_threads

運行輸出與時間順序

程序啟動後兩個線程幾乎立刻輸出：

线程1 开始调用 io.run()，线程 id = 140000000000001
线程2 开始调用 io.run()，线程 id = 140000000000002

約 1 秒後，兩個 timer 都到期，輸出可能類似：

timer1 回调执行，线程 id = 140000000000001
timer2 回调执行，线程 id = 140000000000002
线程1 的 io.run() 返回
线程2 的 io.run() 返回
main：两个线程都结束

也可能兩個回調都被同一個線程執行。線程調度不保證固定。

本示例需要注意的點

這個示例的重點是：

谁调用 io.run()，谁就有可能执行回调函数。

不是 timer1 固定屬於線程 1，timer2 固定屬於線程 2。

std::thread 裡的 std::bind

這句：

std::thread t1(std::bind(run_io, &io, std::string("线程1")));

意思是創建一個線程，在新線程裡執行：

run_io(&io, "线程1");

這裡也沒有使用 lambda。

示例 8：多線程下使用 strand 避免回調併發

程序目標

如果多個線程同時 run() 一個 io_context，不同回調可能同時執行。
如果這些回調都要修改同一個成員變量，就可能出現數據競爭。

strand 的作用是：

保证绑定到同一个 strand 上的 handler 不会并发执行。

完整代碼

#include <boost/asio.hpp>
#include <boost/system/error_code.hpp>
#include <chrono>
#include <functional>
#include <iostream>
#include <thread>

class StrandCounter
{
public:
    explicit StrandCounter(boost::asio::io_context& io)
        : strand_(boost::asio::make_strand(io)),
          timer1_(io, std::chrono::seconds(1)),
          timer2_(io, std::chrono::seconds(1)),
          count_(0)
    {
        // 注册异步等待：这一行不会阻塞，回调会在定时器到期后执行。
        timer1_.async_wait(
            boost::asio::bind_executor(
                strand_,
                std::bind(&StrandCounter::on_timer,
                          this,
                          std::placeholders::_1,
                          1)));

        timer2_.async_wait(
            boost::asio::bind_executor(
                strand_,
                std::bind(&StrandCounter::on_timer,
                          this,
                          std::placeholders::_1,
                          2)));
    }

private:
    void on_timer(const boost::system::error_code& ec, int id)
    {
        if (ec)
        {
            std::cout << "timer" << id << " 取消：" << ec.message() << std::endl;
            return;
        }

        ++count_;

        std::cout << "timer" << id << " 回调执行，count = " << count_
                  << "，线程 id = " << std::this_thread::get_id() << std::endl;
    }

private:
    boost::asio::strand<boost::asio::io_context::executor_type> strand_;
    // 创建定时器，并设置到期时间。
    boost::asio::steady_timer timer1_;
    boost::asio::steady_timer timer2_;
    int count_;
};

void run_io(boost::asio::io_context* io, const std::string& name)
{
    std::cout << name << " 开始 run，线程 id = "
              << std::this_thread::get_id() << std::endl;

    io->run();

    std::cout << name << " run 返回" << std::endl;
}

int main()
{
    // 程序从 main 函数开始执行，下面的语句会按顺序运行。
    // io_context 是 Asio 的事件循环对象，异步任务需要靠它调度。
    boost::asio::io_context io;
    StrandCounter counter(io);

    std::thread t1(std::bind(run_io, &io, std::string("线程1")));
    std::thread t2(std::bind(run_io, &io, std::string("线程2")));

    t1.join();
    t2.join();

    std::cout << "main：结束" << std::endl;

    return 0;
}

運行結果：見下方“運行輸出與時間順序”；如果示例涉及定時器、線程、網絡或外部設備，具體時間和順序可能會隨環境略有變化。

編譯運行

g++ demo8_strand.cpp -o demo8_strand -std=c++17 -lboost_system -pthread
./demo8_strand

運行輸出與時間順序

程序啟動後兩個線程開始 run()：

线程1 开始 run，线程 id = 140000000000001
线程2 开始 run，线程 id = 140000000000002

約 1 秒後兩個 timer 到期：

timer1 回调执行，count = 1，线程 id = 140000000000001
timer2 回调执行，count = 2，线程 id = 140000000000002
线程1 run 返回
线程2 run 返回
main：结束

線程 id 和 timer 順序不固定，但 count 不會出現兩個回調同時改它的併發問題。

本示例需要注意的點

strand 不是讓所有回調固定在同一個線程。
strand 是保證這些回調“不同時執行”。

也就是說，可能是：

timer1 在线程1执行
timer2 在线程2执行

但不會出現：

timer1 和 timer2 同时进入 on_timer()

bind_executor 說明

這段：

boost::asio::bind_executor(strand_, handler)

作用：把 handler 綁定到 strand_ 這個執行器上。

以後 handler 執行時，會遵守這個 strand 的串行化規則。

本節總結

你現在應該記住：

  1. timer.wait() 是同步阻塞。
  2. timer.async_wait() 是註冊異步任務，不阻塞。
  3. io.run() 才是事件循環的入口。
  4. 一個線程 run()，回調就在這個線程裡順序執行。
  5. 多個線程 run()，回調可能被不同線程執行。
  6. 多線程共享數據時，用 strand 避免回調併發。
  7. 類裡綁定成員函數的標準寫法是：
std::bind(&ClassName::member_function,
          this,
          std::placeholders::_1,
          std::placeholders::_2)
音乐页