第 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 改成异步写法：
- 注册一个 2 秒定时器；
async_wait()不阻塞；io.run()开始阻塞；- 2 秒后回调函数被执行；
- 没有任务后
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：
timer11 秒后到期；timer23 秒后到期；- 两个 timer 都在同一个
io_context里； 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：
timer1_1 秒后执行；timer2_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 的串行化规则。
本节总结
你现在应该记住：
timer.wait()是同步阻塞。timer.async_wait()是注册异步任务，不阻塞。io.run()才是事件循环的入口。- 一个线程
run()，回调就在这个线程里顺序执行。 - 多个线程
run()，回调可能被不同线程执行。 - 多线程共享数据时，用
strand避免回调并发。 - 类里绑定成员函数的标准写法是：
std::bind(&ClassName::member_function,
this,
std::placeholders::_1,
std::placeholders::_2)