Boost.Asio 可用于如socket等IO对象的同步或异步操作.在使用Boost.Asio前了解Boost.Asio概念图, 及与应用程序的相互集成是很有帮助的.

第一个范例,看看处理socket连接的情况.首先从同步操作开始.

应用程序 必须有一个 io_service 对象. io_service 对象负责连接应用程序与操作系统的IO服务.

boost::asio::io_service io_service;

要执行IO操作应用程序需要一个像TCP Socket的IO对象:

boost::asio::ip::tcp::socket socket(io_service);

而后执行同步连接操作,发送如下事件:

1. 应用程序 通过调用IO对象初始化连接操作:

socket.connect(server_endpoint);

2. IO对象向 io_service 提出请求.

3. io_service 调用 操作系统 功能执行连接操作.

4. 操作系统向 io_service 返回执行结果.

5. io_service 将错误的操作结果翻译为boost::system::error_code类型. error_code可与特定值进行比较,或作为boolean值检测(false表示无错误).结果再传递给 IO对象 .

6. 如果操作失败,IO对象抛出boost::system::system_error类型的异常.开始操作的代码如下所示:

boost::system::error_code ec;

socket.connect(server_endpoint, ec);

而后error_code类型的变量ec被赋予操作的结果值,但不会抛出异常.

对于异步操作,事件顺序不同.

1. 应用程序 调用 IO 对象进行连接操作:

socket.async_connect(server_endpoint, your_completion_handler);

your_completion_handler函数的签名为:

void your_completion_handler(const boost::system::error_code& ec);

执行的异步操作需要严格的函数签名.每种操作的合法形式可见参考文档.

2. IO对象请求 io_service .

3. io_service 通知 操作系统 其需要开始一个异步连接.

时序过程.(在同步情况下等待包括连接操作时间.)

4. 操作系统 指示连接操作完成, io_service 从队列中获取操作结果.

5. 应用程序 必须调用io_service::run()(或 io_service 相似的成员函数)以便于接收结果.调用io_service::run()会阻塞未完成的异步操作,因此可在启动第一个异步操作后调用这个函数.

6. 调用io_service::run()后,io_service返回一个操作结果,并将其翻译为error_code,传递到事件处理器中.

这是Boost.Asio的简单图形.更多特性可从文档中获取,如使用Boost.Asio执行其他类型的异步操作.

Boost.Asio库同时支持同步和异步操作.异步支持基于Proactor设计模式.下面讨论这种方式与同步操作及Reactor方式相比的优缺点.

现在讨论Proactor不依赖平台细节的特性.

— 异步操作 :定义一个异步执行操作,如Socket异步读写.

— 异步操作处理器 :执行异步操作并在操作完成后执行完成事件队列中的队列事件.从更高层次上说,服务端的stream_socket_service 就是一个异步操作处理器.

— 完成事件队列 :缓冲完成事件,直到被异步事件信号分离器移出队列.

— 完成句柄 :处理异步操作的结果.这是一个函数对象,通常使用boost::bind创建.

— 异步事件信号分离器 :在完成事件队列中阻塞等待事件,受信后向调用者返回完成事件.

— Proactor :调用异步事件信号分离器将事件移出队列,并为这个事件分配一个完成句柄(如调用函数对象).这个功能封装在io_service类中.

— 初始化器 : 执行特定程序代码启动异步操作.初始化器通过如basic_stream_socket等高层次接口与异步操作处理器交互,其返回stream_socket_service等类型的服务代理.

在很多平台上Boost.Asio按照Reactor来实现Proactor设计模式,如select,epoll或kqueue.相对于Proactor其实现方式如下:

— 异步操作处理器 :Reactor使用select,epoll或kqueue机制实现.如果reactor指示运行操作的资源已经就位,处理器执行异步操作并在完成事件队列中插入相应的完成句柄.

— 完成事件队列 :完成句柄的链表(如函数对象).

— 异步事件信号分离器 :在事件或条件变量上等待,直到完成事件队列中的完成句柄可用.

在Windows NT,2000,和XP系统中, Boost.Asio使用重叠IO高效实现了Proactor设计模式:

— 异步操作处理器 :由操作系统实现.操作调用如AcceptEx等重叠函数进行初始化.

— 完成事件队列 :由操作系统实现,与IO完成端口相关联.每个io_service实例对应一个IO完成端口.

— 异步事件信号分离器 :由Boost.Asio从队列中移除事件及其相关联的完成句柄.

— 可移植性Portability: 很多操作系统都提供原生的异步操作IO API(如Windows中的重叠IO),是开发者开发高性能网络应用程序的最佳选择.ASIO库可能实现了原生的异步IO.如果原生支持不可用,ASIO库可使用同步事件信号分离器实现典型的Reactor模式,如POSIX的select().

— 去除多线程并发的耦合

应用程序使用异步方式调用长时间运行的操作.但应用程序不必为增加并发而产生大量的线程.

每个连接一个线程的实现策略(仅需要同步的方式)--太多的线程会产生大量的CPU上下文切换,同步和数据移动,导致系统效率降低.异步操作通过最小化操作系统线程数量来可以避免线程上下文切换的代价--CPU是典型的有限资源,这时仅由激活的逻辑线程进行事件处理.

— 简单的应用程序同步.

异步操作完成句柄可以在已存在的单线程环境中进行设置,此时开发出来的应用程序逻辑清晰,不必涉及同步问题.

— 功能组合.

功能组合指实现高层次操作的功能,如按特定格式发送消息.每个功能的实现都是依赖于多次调用底层的读或写操作.

例如, 一个包含固定长度包头和变长包体的协议,包体长度在包头中指定.假设read_message操作由两个底层的读来实现,第一次接收包头,得到长度,第二次接收包体.

如果用异步方式来组合这些功能,可将这些异步调用连接到一起.前一个操作的完成句柄初始化下一个操作.封装链中的第一个操作的调用,使调用者不会意识到这个高层次的操作是按异步操作链的方式实现的.

按此方式可以很简单的向网路库中添加新的操作,开发出更高层次的抽象,如特定协议的功能和支持.

— 抽象复杂.

由于操作初始化和完成在时间和空间上是分离的,增加了使用异步机制开发程序的难度.而且控制流颠倒使应用程序很难调试.

— 内存占用.

在读和写过程中必须独占缓冲区空间,而后又变为不确定的,每个并发操作都需要一个独立的缓冲区.在Reactor模式中,换句话说,直到socket准备读或写时才需要缓冲区空间.

通常在每个并发操作中使用独立的对象是安全的,但并发操作中使用同一个对象就不安全了.然而如io_service 等类型可以保证并发操作中使用同一个对象也是安全的.

在多个线程中调用io_service::run()函数,就可以创建一个包含这些线程的线程池,其中的线程在异步操作完成后调用完成句柄.也可通过调用io_service::post()实现横跨整个线程池的任意计算任务来达到相同的目的.

注意所有加入io_service池的线程都是平等的,io_service可以按任意的方式向其分配工作.

这个库的特定平台实现会创建几个内部线程来模拟异步操作.同时,这些线程对库用户是不可见的.这些线程特性:

使用如下担保来实现:

因此,由库的使用者来建立和管理投递通知的线程.

Strand被定义为严格按顺序调用(如无并发调用)事件句柄的机制.使用Strand可以在多线程程序中同步执行代码而无需显式地加锁(如互斥量等).

Strand可以按如下两种方式来隐式或显式的应用:

· 仅在一个线程中调用io_service::run()意味着所有的事件句柄都执行在一个隐式的Strand下,因为io_service保证所有的句柄都在run()中被调用.

· 链接中只有一个相关的异步操作链(如半双工的HTTP)是不可能并发执行句柄的.也是隐式Strand的情况.

· 显式Strand需要创建一个io_service::strand实例.所有的事件句柄函数对象都需要使用io_service::strand::wrap()进行包装,或使用io_service::strand进行投递或分发.

在组合异步操作中,如async_read() 或 async_read_until(),如果完成句柄使用一个Strand管理,则其他所有中间句柄都要由同一个Strand来管理.这可以确保线程安全的访问所有在调用者和组合的操作中共享的对象(例如socket中的async_read(),调用者可以调用close()来取消操作).这是通过在所有中间句柄中添加一个钩子函数实现的,在执行最终句柄前调用自定义的钩子函数:

struct my_handler

void operator()() { ... }

template<class F>

void asio_handler_invoke(F f, my_handler*)

// Do custom invocation here.

// Default implementation calls f();

io_service::strand::wrap()函数生成一个新的定义了asio_handler_invoke的完成句柄,以便于Strand管理函数对象运行.

通常IO在连续的内存区域(缓冲区)内传输数据.这个缓冲区可以简单的认为是包含了一个指针地址和一些字节的东西.然而,为了高效的开发网络应用程序, Boost.Asio支持分散聚合操作,需要一个或多个缓冲区:

因此需要一个抽象概念代表缓冲区集合.为此Boost.Asio定义了一个类(实际上是两个类)来代表单个缓冲区.可存储在向分散集合操作传递的容器中.

此外可将缓冲区看做是一个具有地址和大小的字节数组, Boost.Asio区别对待可修改内存(叫做mutable)和不可修改内存(后者在带有const声明的存储区域上创建).这两种类型可以定义为:

typedef std::pair<void*, std::size_t> mutable_buffer;

typedef std::pair<const void*, std::size_t> const_buffer;

这里mutable_buffer 可以转换为const_buffer ,但反之不成立.

然而,Boost.Asio没有使用上述的定义,而是定义了两个类: mutable_buffer 和 const_buffer.目的是提供了不透明的连续内存概念:

类boost::asio::basic_streambuf从std::basic_streambuf继承,将输入输出流与一个或多个字符数组类型的对象相关联,其中的每个元素可以存储任意值.这些字符数组对象是内部的streambuf对象,但通过直接存取数组中的元素使其可用于IO操作,如在socket中发送或接收:

buffers_iterator<>类模板可用于像遍历连续字节序列一样遍历缓冲区序列(如MutableBufferSequence 或 ConstBufferSequence).并提供了buffers_begin() 和 buffers_end()帮助函数, 会自动推断buffers_iterator<>的模板参数.

例如,从socket中读取一行数据,存入std::string中:

boost::asio::streambuf sb;

std::size_t n = boost::asio::read_until(sock, sb, '\n');

boost::asio::streambuf::const_buffers_type bufs = sb.data();

std::string line(

    boost::asio::buffers_begin(bufs),

    boost::asio::buffers_begin(bufs) + n);

有些标准库实现,如VC++8.0或其后版本,提供了叫做迭代器调试的特性.这意味着运行期会验证迭代器是否合法.如果应用程序试图使用非法的迭代器,会抛出异常.例如:

std::vector<int> v(1)

std::vector<int>::iterator i = v.begin();

v.clear(); // invalidates iterators

*i = 0; // assertion!

Boost.Asio 利用这个特性实现缓冲区调试.对于下面的代码:

void dont_do_this()

 std::string msg = "Hello, world!";

 boost::asio::async_write(sock, boost::asio::buffer(msg), my_handler);

当调用异步读或写时需要确保此操作的缓冲区在调用完成句柄时可用.上例中,缓冲区是std::string变量msg.变量在栈中,异步完成前已经过期了.如果幸运的话程序崩溃,但更可能会出现随机错误.

当缓冲区调试启动后,Boost.Asio会存储一个字符串的迭代器,一直保存到异步操作完成,然后解引用来检查有效性.上例中在Boost.Asio调用完成句柄前就会看到一个断言错误.

当定义_GLIBCXX_DEBUG 选项时,会自动在VS8.0及其以后版本和GCC中启动这个特性.检查需要性能代价,因此缓冲区调试只在debug生成时启用.其他编译器可通过定义BOOST_ASIO_ENABLE_BUFFER_DEBUGGING选项来启动.也可显式的通过BOOST_ASIO_DISABLE_BUFFER_DEBUGGING选项停止.

很多Boost.Asio中的IO对象都是基于流的.意味着:

提供基于流IO操作模型的对象需要模拟如下几个操作:

基于流的IO对象包括ip::tcp::socket, ssl::stream<>, posix::stream_descriptor, windows::stream_handle等等.

通常程序需要传递指定数量的字节数据.启动操作后就会发生短读或短写,直到所有数据传输完毕.Boost.Asio提供了通用函数来自动完成这些操作: read(), async_read(), write() 和 async_write().

有时应用程序必须整合第三方的库来实现IO操作.为此,Boost.Asio提供一个可用于读和写操作的null_buffers类型.null_buffers直到IO对象准备好执行操作后才会返回.

例如,如下代码执行无阻塞读操作:

ip::tcp::socket socket(my_io_service);

socket.non_blocking(true);

socket.async_read_some(null_buffers(), read_handler);

void read_handler(boost::system::error_code ec)

  if (!ec)

    std::vector<char> buf(socket.available());

    socket.read_some(buffer(buf));

Socket在所有平台上都支持这种操作,是POSIX基于流的描述符合类.

很多常用的网络协议都是基于行的,即这些协议元素被字符序列"\r\n"限定.例如HTTP,SMTP和FTP.为了便于实现基于行的协议,以及其他使用分隔符的协议,Boost.Asio包括了read_until() 和 async_read_until()函数.

如下代码展示在HTTP服务端使用async_read_until()接收客户端的第一行HTTP请求:

class http_connection

  void start()

    boost::asio::async_read_until(socket_, data_, "\r\n",

        boost::bind(&http_connection::handle_request_line, this, _1));

  void handle_request_line(boost::system::error_code ec)

    if (!ec)

      std::string method, uri, version;

      char sp1, sp2, cr, lf;

      std::istream is(&data_);

      is.unsetf(std::ios_base::skipws);

      is >> method >> sp1 >> uri >> sp2 >> version >> cr >> lf;

  boost::asio::ip::tcp::socket socket_;

  boost::asio::streambuf data_;

Streambuf数据成员用于存储在查找到分隔符前接收的数据.记录分隔符以后的数据也是很重要的.这些保留在streambuf中的冗余数据会被保留下来用于随后调用的read_until()或async_read_until()函数进行检查.

分隔符可以是单个字符,一个std::string或一个boost::regex. read_until() 和 async_read_until()函数也可接收一个用户定义函数作为参数,获取匹配条件.例如,在streambuf中读取数据,遇到一个空白字符后停止.:

typedef boost::asio::buffers_iterator<

    boost::asio::streambuf::const_buffers_type> iterator;

std::pair<iterator, bool>

match_whitespace(iterator begin, iterator end)

  iterator i = begin;

  while (i != end)

    if (std::isspace(*i++))

      return std::make_pair(i, true);

  return std::make_pair(i, false);

boost::asio::streambuf b;

boost::asio::read_until(s, b, match_whitespace);

从streambuf中读取数据,直到遇到匹配的字符:

class match_char

public:

  explicit match_char(char c) : c_(c) {}

  template <typename Iterator>

  std::pair<Iterator, bool> operator()(

      Iterator begin, Iterator end) const

    Iterator i = begin;

    while (i != end)

      if (c_ == *i++)

        return std::make_pair(i, true);

    return std::make_pair(i, false);

private:

  char c_;

namespace boost { namespace asio {

  template <> struct is_match_condition<match_char>

    : public boost::true_type {};

} } // namespace boost::asio

boost::asio::streambuf b;

boost::asio::read_until(s, b, match_char('a'));

is_match_condition<>类型会自动的对函数,及带有嵌套result_type类型定义的函数对象的返回值值进行评估是否为true.如上例所示,其他类型的特性必须显式指定.

很多异步操作需要分配对象,用来存储与操作有关的状态数据.例如,Win32的实现中需要将重叠子对象传递给Win32 API函数.

幸好程序包含一个易于识别的异步操作链.半双工协议(如HTTP服务)为每个客户端创建一个单操作链.全双工协议实现有两个并行的执行链.程序运用这个规则可以在链上的所有异步操作中重用内存.

假设复制一个用户定义的句柄对象h,如果句柄的实现需要分配内存,应该有如下代码:

void* pointer = asio_handler_allocate(size, &h);

同样要释放内存:

asio_handler_deallocate(pointer, size, &h);

这个函数实现了参数依赖的定位查找.asio空间中有这个函数的默认实现:

void* asio_handler_allocate(size_t, ...);

void asio_handler_deallocate(void*, size_t, ...);

实现了::operator new() 和 ::operator delete()功能.

函数实现保证了相关句柄调用前会发生内存重新分配,这样就可以实现同一个句柄上的异步操作重用内存.

在任意调用库函数的用户线程中都可调用自定义内存分配函数.实现保证库中的这些异步操作不会并发的对句柄进行内存分配函数调用.实现要加入适当的内存间隔,保证不同线程中调用的内存分配函数有正确的内存可见性.

为调试异步程序,Boost.Asio提供了句柄跟踪支持.当激活BOOST_ASIO_ENABLE_HANDLER_TRACKING定义,Boost.Asio向标准错误流中写入调试输出信息.输出信息记录异步操作及其句柄间的关系.

这个特性对调试很有帮助,需要知道异步操作是如何被链接在一起的,或什么异步操作被挂起了.如下是HTTP服务输出的调试信息,处理单个请求,而后按Ctrl+C退出:

@asio|1298160085.070638|0*1|signal_set@0x7fff50528f40.async_wait

@asio|1298160085.070888|0*2|socket@0x7fff50528f60.async_accept

@asio|1298160085.070913|0|resolver@0x7fff50528e28.cancel

@asio|1298160118.075438|>2|ec=asio.system:0

@asio|1298160118.075472|2*3|socket@0xb39048.async_receive

@asio|1298160118.075507|2*4|socket@0x7fff50528f60.async_accept

@asio|1298160118.075527|<2|

@asio|1298160118.075540|>3|ec=asio.system:0,bytes_transferred=122

@asio|1298160118.075731|3*5|socket@0xb39048.async_send

@asio|1298160118.075778|<3|

@asio|1298160118.075793|>5|ec=asio.system:0,bytes_transferred=156

@asio|1298160118.075831|5|socket@0xb39048.close

@asio|1298160118.075855|<5|

@asio|1298160122.827317|>1|ec=asio.system:0,signal_number=2

@asio|1298160122.827333|1|socket@0x7fff50528f60.close

@asio|1298160122.827359|<1|

@asio|1298160122.827370|>4|ec=asio.system:125

@asio|1298160122.827378|<4|

@asio|1298160122.827394|0|signal_set@0x7fff50528f40.cancel

每行的格式为:

<tag>|<timestamp>|<action>|<description>

<tag>一直是@asio,用于在程序输出中识别和提取句柄跟踪消息.

<timestamp> 是从UTC时间1970年一月一日起至今的秒数.

<action> 有如下几种形式:

程序进入了第n个句柄.<description>描述句柄参数.

程序退出第n个句柄.

程序由于异常退出第n个句柄.

第n个句柄没有执行就被销毁了.通常是由于io_service销毁时异步操作还没有完成.

第n个句柄创建了一个生成第m个完成句柄的新异步操作.<description>描述什么异步操作被启动.

第n个句柄执行其他操作.<description>显示调用了哪些函数.通常只记录close()和cancel()操作,因为其影响了异步操作挂起状态.

当<description>显示同步或异步操作,格式为 <object-type>@<pointer>.<operation> . 并以逗号间隔来显示执行句柄的参数和值.

如上所示,每个句柄都由唯一的数字进行标识.句柄跟踪输出的句柄编号是0的,表示操作不是这些句柄执行的.

句柄跟踪输出可以使用包含在 handlerviz.pl 中的工具进行处理,创建可视化的界面.

Boost.Asio 对TCP,UDP和ICMP提供了完整的支持.

使用resolver执行主机名称解析,查询主机和服务名称并转换为一个或多个端点:

ip::tcp::resolver resolver(my_io_service);

ip::tcp::resolver::query query("www.boost.org", "http");

ip::tcp::resolver::iterator iter = resolver.resolve(query);

ip::tcp::resolver::iterator end; // End marker.

while (iter != end)

  ip::tcp::endpoint endpoint = *iter++;

  std::cout << endpoint << std::endl;

上面列表中包含的端点可以是IPv4和IPv6端点,因此程序需要对每种情况进行尝试直到得到一个可用的端点.这使程序不依赖于特定的IP版本.

程序使用接收器来接收到达的TCP连接:

ip::tcp::acceptor acceptor(my_io_service, my_endpoint);

ip::tcp::socket socket(my_io_service);

acceptor.accept(socket);

当成功接收一个socket连接(向如上例中的TCP客户端),就可以在其上读取或写入数据了.

UDP也使用来resolver解析主机名称:

ip::udp::resolver resolver(my_io_service);

ip::udp::resolver::query query("localhost", "daytime");

ip::udp::resolver::iterator iter = resolver.resolve(query);

UDP绑定到了本地端点.如下代码创建一个IPv4的UDP Socket,绑定到任意地址的12345端口上:

ip::udp::endpoint endpoint(ip::udp::v4(), 12345);

ip::udp::socket socket(my_io_service, endpoint);

Boost.Asio 中包含一个在Socket上实现的iostream类.将端点解析,协议无关等复杂特性的实现隐藏起来.要创建连接只需简单的写几行代码:

ip::tcp::iostream stream("www.boost.org", "http");

if (!stream)

  // Can't connect.

iostream 类可以与接收器一起创建简单的服务端.例如:

io_service ios;

ip::tcp::endpoint endpoint(tcp::v4(), 80);

ip::tcp::acceptor acceptor(ios, endpoint);

for (;;)

  ip::tcp::iostream stream;

  acceptor.accept(*stream.rdbuf());

可使用expires_at() 或 expires_from_now()函数设置超时期限.超时的Socket操作会将iostream设置为"bad"状态.

例如,一个简单的客户端程序:

ip::tcp::iostream stream;

stream.expires_from_now(boost::posix_time::seconds(60));

stream.connect("www.boost.org", "http");

stream << "GET /LICENSE_1_0.txt HTTP/1.0\r\n";

stream << "Host: www.boost.org\r\n";

stream << "Accept: */*\r\n";

stream << "Connection: close\r\n\r\n";

stream.flush();

std::cout << stream.rdbuf();

如果所有的Socket操作时间加起来超过60秒则失败.

如果发生错误,可使用iostream的error()成员函数获取最近系统操作的错误码:

if (!stream)

  std::cout << "Error: " << stream.error().message() << "\n";

这个iostream模板只支持char,不支持wchar_t,不要用于这样的代码版本.

Boost.Asio 包含了实现BSD Socket API的低层次Socket接口的库.在其他语言中后者也作为最基本的网络API,如Java.底层次接口可用来开发高效率和高可伸缩性的应用程序.例如,程序员可以更好的控制系统调用次数,避免基础数据拷贝,最小化如线程等资源的使用等.

BSD Socket API包含了不安全和有错误倾向的方面.例如,使用整型数字代表socket缺乏安全性. Boost.Asio 中使用不同的Socket类型代表不用的协议,如TCP对应的是ip::tcp::socket,UDP对应的ip::udp::socket.

下表是BSD Socket API和Boost.Asio的对比:

Boost.Asio 提供了UNIX领域的Socket基本支持(又叫做本地Socket).最简单的使用情况是有一对连接Socket.代码如下:

local::stream_protocol::socket socket1(my_io_service);

local::stream_protocol::socket socket2(my_io_service);

local::connect_pair(socket1, socket2);

将创建一对基于流的Socket.要实现基于数据包的Socket,使用:

local::datagram_protocol::socket socket1(my_io_service);

local::datagram_protocol::socket socket2(my_io_service);

local::connect_pair(socket1, socket2);

UNIX领域的Socket服务可以创建在一个绑定一个端点的接收器上,TCP服务也类似:

::unlink("/tmp/foobar"); // Remove previous binding.

local::stream_protocol::endpoint ep("/tmp/foobar");

local::stream_protocol::acceptor acceptor(my_io_service, ep);

local::stream_protocol::socket socket(my_io_service);

acceptor.accept(socket);

客户端连接到服务端代码:

local::stream_protocol::endpoint ep("/tmp/foobar");

local::stream_protocol::socket socket(my_io_service);

socket.connect(ep);

Boost.Asio不支持跨UNIX领域Socket传输文件描述符或证书,但可以使用native()函数调用Socket的底层描述符来实现.

UNIX领域的Socket仅在支持的平台上编译的时候激活.可以测试BOOST_ASIO_HAS_LOCAL_SOCKETS宏检查是否支持.

Boost.Asio 包含在POSIX文件描述符上同步或异步读写的类,如管道,标准输入输出,和各种设备(但不是常规的文件).

例如,在标准输入输出上执行读写,创建如下对象:

posix::stream_descriptor in(my_io_service, ::dup(STDIN_FILENO));

posix::stream_descriptor out(my_io_service, ::dup(STDOUT_FILENO));

Boost.Asio 包含允许在Windows句柄上执行异步读或写操作的类,如命名管道.

例如,在命名管道上执行异步操作,创建如下对象:

HANDLE handle = ::CreateFile(...);

windows::stream_handle pipe(my_io_service, handle);

Boost.Asio提供特定的类实现在规则文件相关句柄上执行异步读写操作.

例如,在文件上执行异步操作代码:

HANDLE handle = ::CreateFile(...);

windows::random_access_handle file(my_io_service, handle);

SSL流对象在无锁定的情况下执行.因此,异步执行SSL都需要隐式或显式的应用strand.注意这意味着在单线程程序中不需同步控制(不必使用锁).

C++支持移动对象后(通过右值引用),Boost.Asio可以对socket,串口,POSIX描述符和Windows句柄进行移动构造和赋值.

通过移动对象可实现如下代码:

tcp::socket make_socket(io_service& i)

  tcp::socket s(i);

  std::move(s);

class connection : public enable_shared_from_this<connection>

private:

  tcp::socket socket_;

public:

  connection(tcp::socket&& s) : socket_(std::move(s)) {}

class server

private:

  tcp::acceptor acceptor_;

  tcp::socket socket_;

  void handle_accept(error_code ec)

    if (!ec)

      std::make_shared<connection>(std::move(socket_))->go();

    acceptor_.async_accept(socket_, ...);

std::vector<tcp::socket> sockets;

sockets.push_back(tcp::socket(...));

一字真言:当异步操作挂起时是可以继续移动对象的,但这不是一个好主意.特别是操作由如async_read()等函数触发时其引用了流对象.在操作期间移动对象将会导致相应操作访问已移动的对象.

移动支持在g++4.5及以后版本加入 -std=c++0x 或 -std=gnu++0x 编译选项即可自动支持.可通过BOOST_ASIO_DISABLE_MOVE定义宏禁用或BOOST_ASIO_HAS_MOVE宏激活.注意这些宏还会影响可移动句柄.

优化后,用户定义的完成句柄可支持移动构造,Boost.Asio的实现会优先于拷贝构造函数使用移动构造函数.当前环境下,Boost.Asio也可能去除所有句柄的拷贝构造函数.然而,句柄类型还是需要拷贝构造函数的.

当激活移动支持,异步代码为:

template <typename Handler>

void async_XYZ(..., Handler handler);

实际上声明为:

template <typename Handler>

void async_XYZ(..., Handler&& handler);

句柄参数在async_XYZ函数体内部完美的传递,并发生了移动构造.这可确保函数的所有其他参数都会提前评估移动.尤其是在async_XYZ()的其他参数为句柄的成员时更重要.例如:

struct my_operation

  shared_ptr<tcp::socket> socket;

  shared_ptr<vector<char>> buffer;

  void operator(error_code ec, size_t length)

    socket->async_read_some(boost::asio::buffer(*buffer), std::move(*this));

移动支持在g++4.5及以后版本加入 -std=c++0x 或 -std=gnu++0x 编译选项即可自动支持.可通过BOOST_ASIO_DISABLE_MOVE定义宏禁用或BOOST_ASIO_HAS_MOVE宏激活.注意这些宏还会影响可移动IO对象.

在如下平台和编译器下测试通过:

也可用于如下平台:

为使程序可连接到Boost.Asio如下库必须可用:

而且有些范例需要Boost.Thread, Boost.Date_Time 或 Boost.Serialization库的支持.

可以按需要生成Boost的子库,下例在Boost的根目录中运行命令行:

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

这里假设已经生成了bjam.更多信息见Boost.Build文档.

默认情况下,Boost.Asio仅是一个有头文件的库.然而,有些开发者更愿意分开编译Boost.Asio的源码.只需要在程序的源文件中加入#include <boost/asio/impl/src.hpp>,而后在项目/编译器设置中加入BOOST_ASIO_SEPARATE_COMPILATION编译选项并进行编译.或者使用BOOST_ASIO_DYN_LINK选项将Boost.Asio独立编译为静态库.