Boost.Asio 入门

本章先回答两个问题：什么是 Boost.Asio？怎么编译它？在了解的过程中我们会给出一些例子，你也会在发现 Boost.Asio 不仅仅是一个网络库的同时，接触到它最核心的类——io_service。

什么是Boost.Asio

简单来说，Boost.Asio是一个跨平台的、主要用于网络和其他一些底层输入/输出编程的C++库。

计算机网络的设计方式有很多种，但是Boost.Asio的方式远远优于其它的设计方式。它在2005年就被包含进Boost，然后被大量Boost的用户测试并在很多项目中使用，比如Remobo，可以让你创建你自己的即时私有网络(IPN)的应用，libtorrent一个实现了比特流客户端的库，PokerTH一个支持LAN和互联网对战的纸牌游戏。

Boost.Asio在网络通信、COM串行端口和文件上成功地抽象了输入输出的概念。你可以基于这些进行同步或者异步的输入输出编程。

read(stream, buffer [, extra options])
async_read(stream, buffer [, extra options], handler)
write(stream, buffer [, extra options])
async_write(stream, buffer [, extra options], handler)

这些都是自由函数（free function）：接受一个流对象——socket 只是其中一种——再加上缓冲区等参数。后面你会看到，串口、文件同样可以使用它们。

作为一个跨平台的库，Boost.Asio可以在大多数操作系统上使用。能同时支持数千个并发的连接。其网络部分的灵感来源于伯克利软件分发(BSD)socket，它提供了一套可以支持传输控制协议(TCP)socket、用户数据报协议(UDP)socket和Internet控制消息协议(ICMP)socket的API，而且如果有需要，你可以对其进行扩展以支持你自己的协议。

历史

Boost.Asio 在 2003 年被开发出来，2005 年 12 月被 Boost 正式接受，随后随 Boost 1.35 版本一同发布。原作者是Christopher M. Kohlhoff，你可以通过 chris@kohlhoff.com 联系他。

这个库在以下的平台和编译器上测试通过：

• Microsoft Windows：Visual Studio 2005 及以上
• Linux：GCC 4.x 及以上
• Mac OS X：GCC（Xcode）
• FreeBSD：GCC
• Solaris：GCC / Sun Studio

它也可能能在诸如AIX 5.3，HP-UX 11i v3，QNX Neutrino 6.3，Solaris下使用Sun Studio 11以上，True64 v5.1，Windows下使用Borland C++ 5.9.2以上等平台上使用。（更多细节请参见 www.boost.org）

依赖

Boost.Asio依赖于如下的库：

• Boost.System：必需
• Boost.Regex：如果你使用 read_until 或 async_read_until
• Boost.Date_Time：如果你使用计时器

编译Boost.Asio

Boost.Asio是一个只需要引入头文件就可以使用的库。然而，考虑到你的编译器和程序的大小，你可以选择用源文件的方式来编译Boost.Asio。如果你想要这么做以减少编译时间，有如下几种方式：

• 在某个源文件中，添加 #include "boost/asio/impl/src.hpp"（如果你在使用SSL，添加 #include "boost/asio/ssl/impl/src.hpp"）
• 在所有的源文件中，添加 #define BOOST_ASIO_SEPARATE_COMPILATION

注意Boost.Asio依赖于Boost.System，必要的时候还依赖于Boost.Regex，所以你需要用如下的指令先编译Boost：

bjam --with-system --with-regex stage

如果你还想同时编译tests，你需要使用如下的指令：

bjam --with-system --with-thread --with-date_time --with-regex --with-serialization stage

这个库自带大量示例，值得一并翻阅。

重要的宏

如果设置了BOOST_ASIO_DISABLE_THREADS；不管你是否在编译Boost的过程中使用了线程支持，Boost.Asio中的线程支持都会失效。

同步VS异步

首先，异步编程和同步编程是非常不同的。在同步编程中，所有的操作都是顺序执行的，比如从socket中读取（请求），然后写入（回应）到socket中。每一个操作都是阻塞的。因为操作是阻塞的，所以为了不影响主程序，当在socket上读写时，通常会创建一个或多个线程来处理socket的输入/输出。因此，同步的服务端/客户端通常是多线程的。

相反的，异步编程是事件驱动的。虽然启动了一个操作，但是你不知道它何时会结束；它只是提供一个回调给你，当操作结束时，它会调用这个API，并返回操作结果。对于有 Qt 这类事件驱动框架丰富经验的程序员来说，这就是第二天性。因此，在异步编程中，你只需要一个线程。

因为中途做改变会非常困难而且容易出错，所以你在项目初期（最好是一开始）就得决定用同步还是异步的方式实现网络通信。不仅API有极大的不同，你程序的语意也会完全改变（异步网络通信通常比同步网络通信更加难以测试和调试）。你需要考虑是采用阻塞调用和多线程的方式（同步，通常比较简单），或者是更少的线程和事件驱动（异步，通常更复杂）。

下面是一个基础的同步客户端例子：

using boost::asio;
io_service service;
ip::tcp::endpoint ep( ip::address::from_string("127.0.0.1"), 2001);
ip::tcp::socket sock(service);
sock.connect(ep);

首先，你的程序至少需要一个io_service实例。Boost.Asio使用io_service同操作系统的输入/输出服务进行交互（io_service 的深入剖析可以看本站的《深入理解 Boost.Asio 的 io_service》）。通常一个io_service的实例就足够了。然后，创建你想要连接的地址和端口，再建立socket。把socket连接到你创建的地址和端口。

下面是一个简单的使用Boost.Asio的服务端：

typedef boost::shared_ptr<ip::tcp::socket> socket_ptr;
io_service service;
ip::tcp::endpoint ep(ip::tcp::v4(), 2001); // 监听 2001 端口
ip::tcp::acceptor acc(service, ep);

// 每个客户端连接由一个线程处理
void client_session(socket_ptr sock) {
    while (true) {
        char data[512];
        size_t len = sock->read_some(buffer(data));
        if (len > 0)
            write(*sock, buffer("ok", 2));
    }
}

int main() {
    socket_ptr sock(new ip::tcp::socket(service));
    acc.accept(*sock);
    boost::thread(boost::bind(client_session, sock));
}

首先，同样是至少需要一个io_service实例。然后你指定你想要监听的端口，再创建一个接收器——一个用来接收客户端连接的对象。 在接下来的循环中，你创建一个虚拟的socket来等待客户端的连接。然后当一个连接被建立时，你创建一个线程来处理这个连接。

在client_session线程中来读取一个客户端的请求，进行解析，然后返回结果。

而创建一个异步的客户端，你需要做如下的事情：

using boost::asio;
io_service service;
ip::tcp::endpoint ep(ip::address::from_string("127.0.0.1"), 2001);
ip::tcp::socket sock(service);

// 连接完成的回调
void connect_handler(const boost::system::error_code &ec) {
    // 如果 ec 表示成功，我们就知道连接已经建立
}

int main() {
    sock.async_connect(ep, connect_handler);
    service.run();
}

在程序中你需要创建至少一个io_service实例。你需要指定连接的地址以及创建socket。

当连接完成时，connect_handler 会被调用。在回调里检查错误码 ec，如果成功，你就可以向服务端进行异步的读写了。

注意：只要还有待处理的异步操作，service.run()循环就会一直运行。在上述例子中，只执行了一个这样的操作，就是socket的async_connect。在这之后，service.run()就退出了。

每一个异步操作都有一个完成处理程序——一个操作完成之后被调用的函数。 下面的代码是一个基本的异步服务端

using boost::asio;
typedef boost::shared_ptr<ip::tcp::socket> socket_ptr;
io_service service;
ip::tcp::endpoint ep(ip::tcp::v4(), 2001); // 监听 2001 端口
ip::tcp::acceptor acc(service, ep);

void handle_accept(socket_ptr sock, const boost::system::error_code &err);

// 发起一次异步等待客户端连接
void start_accept(socket_ptr sock) {
    acc.async_accept(*sock, boost::bind( handle_accept, sock, _1));
}

// accept 完成的回调
void handle_accept(socket_ptr sock, const boost::system::error_code &err) {
    if (err) return;
    // 从这里开始，你可以对 sock 进行读写了
    socket_ptr new_sock(new ip::tcp::socket(service));
    start_accept(new_sock); // 用新 socket 继续等待下一个客户端
}

int main() {
    socket_ptr sock(new ip::tcp::socket(service));
    start_accept(sock);
    service.run();
}

在上述代码片段中，首先，你创建一个io_service实例，指定监听的端口。然后，你创建接收器acc——一个接受客户端连接，创建虚拟的socket，异步等待客户端连接的对象。

最后，运行异步service.run()循环。当接收到客户端连接时，handle_accept被调用（调用async_accept的完成处理程序）。如果没有错误，这个socket就可以用来做读写操作。

在使用这个socket之后，你创建了一个新的socket，然后再次调用start_accept()，用来创建另外一个“等待客户端连接”的异步操作，从而使service.run()循环一直保持忙碌状态。

异常处理VS错误代码

Boost.Asio允许同时使用异常处理或者错误代码，所有的异步函数都有抛出错误和返回错误码两种方式的重载。当函数抛出错误时，它通常抛出boost::system::system_error的错误。

using boost::asio;
ip::tcp::endpoint ep;
ip::tcp::socket sock(service);
sock.connect(ep); // 第一行
boost::system::error_code err;
sock.connect(ep, err); // 第二行

在前面的代码中，sock.connect(ep)会抛出错误，sock.connect(ep, err)则会返回一个错误码。

看一下下面的代码片段：

try {
    sock.connect(ep);
} catch (const boost::system::system_error& e) {
    std::cout << e.code() << std::endl;
}

下面的代码片段和前面的是一样的：

boost::system::error_code err;
sock.connect(ep, err);
if (err)
    std::cout << err << std::endl;

当使用异步函数时，你可以在你的回调函数里面检查其返回的错误码。异步函数从来不抛出异常，因为这样做毫无意义。那谁会捕获到它呢？

在你的异步函数中，你可以使用异常处理或者错误码（随心所欲），但要保持一致性。同时使用这两种方式会导致问题，大部分时候是崩溃（当你不小心出错，忘记去处理一个抛出来的异常时）。如果你的代码很复杂（调用很多socket读写函数），你最好选择异常处理的方式，把你的读写包含在一个函数try {} catch块里面。

void client_session(socket_ptr sock) {
    try {
        ...
    } catch (const boost::system::system_error& e) {
        // 处理错误
    }
}

如果使用错误码，你可以使用下面的代码片段很好地检测连接是何时关闭的：

char data[512];
boost::system::error_code error;
size_t length = sock.read_some(buffer(data), error);
if (error == error::eof)
    return; // 连接关闭

Boost.Asio的所有错误码都包含在boost::asio::error的命名空间中（以便你创造一个大型的switch来检查错误的原因）。如果想要了解更多的细节，请参照boost/asio/error.hpp头文件

Boost.Asio中的线程

当说到 Boost.Asio 的线程时，我们通常在讨论：除了你自己创建的线程，Boost.Asio 内部也可能存在少数线程。但可以保证的是，这些内部线程不会调用你的代码——只有调用了 io_service::run() 方法的线程才会执行你的回调函数。

不仅仅是网络通信

除了网络通信，Boost.Asio还包含了其他的I/O功能。

Boost.Asio支持信号量，比如SIGTERM（软件终止）、SIGINT（中断信号）、SIGSEGV（段错误）等等。 你可以创建一个signal_set实例，指定异步等待的信号量，然后当这些信号量产生时，就会调用你的异步处理程序：

void signal_handler(const boost::system::error_code &err, int signal)
{
    // 纪录日志，然后退出应用
}
boost::asio::signal_set sig(service, SIGINT, SIGTERM);
sig.async_wait(signal_handler);

如果SIGINT产生，你就能在你的signal_handler回调中捕获到它。

你可以使用Boost.Asio轻松地连接到一个串行端口。在Windows上端口名称是COM7，在POSIX平台上是/dev/ttyS0。

io_service service;
serial_port sp(service, "COM7");

打开端口后，你就可以使用下面的代码设置一些端口选项，比如端口的波特率、奇偶校验和停止位。

serial_port::baud_rate rate(9600);
sp.set_option(rate);

打开端口后，你可以把这个串行端口看做一个流，然后基于它使用自由函数对串行端口进行读/写操作。比如async_read(), write, async_write(), 就像下面的代码片段：

char data[512];
read(sp, buffer(data, 512));

Boost.Asio也可以连接到Windows的文件，然后同样使用自由函数，比如 read()、async_read() 等等，就像下面的代码片段：

HANDLE h = ::OpenFile(...);
windows::stream_handle sh(service, h);
char data[512];
read(sh, buffer(data, 512));

对于POSIX文件描述符，比如管道，标准I/O和各种设备（但不包括普通文件）你也可以这样做，就像下面的代码所做的一样：

posix::stream_descriptor sd_in(service, ::dup(STDIN_FILENO));
char data[512];
read(sd_in, buffer(data, 512));

计时器

一些I/O操作需要一个超时时间。这只能应用在异步操作上（同步意味着阻塞，因此没有超时时间）。例如，下一条消息必须在 100 毫秒内从对端传递过来。

bool read = false;
void deadline_handler(const boost::system::error_code &) {
    std::cout << (read ? "read successfully" : "read failed") << std::endl;
}
void read_handler(const boost::system::error_code &) {
    read = true;
}
ip::tcp::socket sock(service);
…
read = false;
char data[512];
sock.async_read_some(buffer(data, 512));
deadline_timer t(service, boost::posix_time::milliseconds(100));
t.async_wait(&deadline_handler);
service.run();

在上述代码片段中，如果你在超时之前读完了数据，read则被设置成true，这样我们的伙伴就及时地通知了我们。否则，当deadline_handler被调用时，read还是false，也就意味着我们的操作超时了。

Boost.Asio也支持同步计时器，但是它们通常和一个简单的sleep操作是一样的。boost::this_thread::sleep(boost::posix_time::milliseconds(500)); 和下面的代码片段完成了同一件事情：

deadline_timer t(service, boost::posix_time::milliseconds(500));
t.wait();

io_service类

你应该已经发现大部分使用Boost.Asio编写的代码都会使用几个io_service的实例。io_service是这个库里面最重要的类；它负责和操作系统打交道，等待所有异步操作的结束，然后为每一个异步操作调用其完成处理程序。

如果你选择用同步的方式来创建你的应用，则不需要考虑我将在这一节展示的内容。使用 io_service 有多种不同的方式。在下面的三个方案中，我们都安排 3 个异步操作：2 个 socket 连接操作和 1 个计时器等待操作。

方案一：单个 io_service，单线程

io_service service;
ip::tcp::socket sock1(service);
ip::tcp::socket sock2(service);
sock1.async_connect(ep, connect_handler);
sock2.async_connect(ep, connect_handler);
deadline_timer t(service, boost::posix_time::seconds(5));
t.async_wait(timeout_handler);
service.run(); // 单线程，完成处理程序依次串行调用

方案二：单个 io_service，线程池

io_service service;
ip::tcp::socket sock1(service);
ip::tcp::socket sock2(service);
sock1.async_connect(ep, connect_handler);
sock2.async_connect(ep, connect_handler);
deadline_timer t(service, boost::posix_time::seconds(5));
t.async_wait(timeout_handler);
for (int i = 0; i < 5; ++i)
    boost::thread(run_service);
void run_service()
{
    service.run();
}

方案三：多个 io_service，每个线程跑一个

io_service service[2];
ip::tcp::socket sock1(service[0]);
ip::tcp::socket sock2(service[1]);
sock1.async_connect(ep, connect_handler);
sock2.async_connect(ep, connect_handler);
deadline_timer t(service[0], boost::posix_time::seconds(5));
t.async_wait(timeout_handler);
for (int i = 0; i < 2; ++i)
    boost::thread(boost::bind(run_service, i));
void run_service(int idx)
{
    service[idx].run();
}

首先，要注意你不能拥有多个io_service实例却只有一个线程。下面的代码片段没有任何意义：

for (int i = 0; i < 2; ++i)
    service[i].run();

上面的代码片段没有意义是因为service[1].run()需要service[0].run()先结束。因此，所有由service[1]处理的异步操作都需要等待，这显然不是一个好主意。

在前面的三个方案中，我们都在等待 3 个异步操作结束。为了解释它们之间的不同点，我们假设：过一会操作 1 先完成，紧接着操作 2 完成。同时假设每个完成处理程序需要 1 秒钟才能执行完。

在方案一中，我们在一个线程里等待全部操作完成：操作 1 一完成，就调用它的完成处理程序。尽管操作 2 紧接着就完成了，但它的完成处理程序必须等 1 秒钟——等操作 1 的完成处理程序执行完毕才会被调用。

在方案二中，我们在多个线程里等待 3 个异步操作结束：操作 1 完成时，某个空闲线程立即调用它的完成处理程序；操作 2 紧接着完成时，另一个空闲线程可以马上调用它的完成处理程序——不会像方案一那样排队等待。

在方案三中，因为操作 1 是 sock1 的 connect（跑在 service[0] 上），操作 2 是 sock2 的 connect（跑在 service[1] 上），所以应用程序表现得和方案二一样。线程1会处理sock1 connect操作的完成处理程序，线程2会处理sock2的connect操作的完成处理程序。然而，如果 deadline_timer t 的超时操作排在操作 2 的位置——它和 sock1 的 connect 同属 service[0]，就必须等 sock1 connect 的完成处理程序执行结束（约 1 秒钟），因为同一线程要串行处理 service[0] 上的所有完成处理程序。

从这三个方案中，你最重要的一课是：如果你觉得应用程序将来可能需要从一种模式切换到另一种，请确保调用 io_service::run() 的这段调度代码和应用程序其他部分是隔离的，这样你就可以很轻松地对其进行更改。

最后，需要一直记住的是如果没有其他需要监控的操作，.run()就会结束，就像下面的代码片段：

io_service service;
tcp::socket sock(service);
sock.async_connect(ep, connect_handler);
service.run();

在上面的例子中，只要sock建立了一个连接，connect_handler就会被调用，然后接着service.run()就会完成执行。

如果你想要service.run()接着执行，你需要分配更多的工作给它。这里有两个方式来完成这个目标。一种方式是在connect_handler中启动另外一个异步操作来分配更多的工作。 另一种方式会模拟一些工作给它，用下面的代码片段：

typedef boost::shared_ptr<io_service::work> work_ptr;
work_ptr dummy_work(new io_service::work(service));

上面的代码可以保证 service.run() 一直运行，直到你调用 service.stop()，或者显式销毁这个 work 对象（dummy_work.reset()）。

总结

作为一个功能复杂的库，Boost.Asio 让网络编程变得异常简单。构建起来也简单。而且在避免使用宏这一点上也做得很好；它虽然定义了少部分的宏来做选项开关，但是你需要关心的很少。

Boost.Asio 支持同步和异步编程。它们有很大不同；你需要在项目早期就选择其中一种，因为两者之间的转换非常复杂而且易错。

错误处理上，你可以选择异常处理或者错误码，而且两者可以随时切换：给调用函数多传一个错误码参数即可。

Boost.Asio不仅仅可以用来做网络编程。它还有其他更多的特性，这让它显得更有价值，比如信号量，计时器等等。

下一章我们将深入研究大量 Boost.Asio 中用来做网络编程的函数和类，同时也会学一些异步编程的诀窍，请看本站的《Boost.Asio 基本原理》。