1、前言
Boost库是一个可移植、提供源代码的C++库，作为标准库的后备，是C++标准化进程的开发引擎之一。Boost库由C++标准委员会库工作组成员发起，其中有些内容有望成为下一代C++标准库内容。在C++社区中影响甚大，是不折不扣的“准”标准库。
boost.asio是Boost库中十分知名的I/O组件，是用于网路和低层IO编程的跨平台C++库，为开发者提供了C++环境下稳定的异步模型。其在性能、移植性、扩展性等方面均为人称道，甚至被好多业内人士称为“网络利器”。asio是目前惟一有希望步入C++标准库以填补标准库在网路方面的缺位的C++网路库，因而对asio的学习在某种意义上可以说是学习C++网路编程的选修课。
当前网路上从用户角度介绍asio的文献好多也很健全，所以本文决定另辟蹊径，从asio源码角度出发，由内而外、深入浅出地探讨asio的构架和设计理念，将asio的一切秘密呈现在读者眼前。
本文适宜已有较健全的C++基础知识、具备一定程度的子类技术和面向对象技术、并对boost.asio有一定的了解的读者。
2、架构探讨
先来看一下asio的0层的组件图。
(图1.0)
io_object是I/O对象的集合，其中包含你们所熟悉的socket、deadline_timer等对象，主要功能是提供插口给用户使用。
services服务是逻辑功能的实现者，其中包含提供定时功能的deadline_timer_service、提供socket相关功能的win_iocp_socket_service(windows平台)/reactive_socket_service(其他平台)、作为io_service功能的真正实现者win_iocp_io_service(windows平台)/task_io_service(其他平台)等等服务。
“Asio核心组件”在这一层中可以理解为就是io_service，它通过关联的类service_registry将实现具体功能所需的服务组合上去，再由io_object提供插口给用户使用。
这三大组件构成了asio的核心构架，asio的一切都是借此为根基衍生扩充下来的。
让我们将图1.0进一步细化：
(图1.1)
“Asio核心组件”细化为4个类:io_service，service_registry，service，service_base。其中，service_registry负责管理所有服务，使用延后创建技术，在真正使用服务对象的时侯才创建服务对象，并以单数组的形式管理，但只能增不能删，直至service_registry析构时就会释放其管理的服务对象。service是io_service的类中类，是一个虚泛型，所有由service_registry管理的服务都必须从service派生。service_base是service的直接派生类，是services承继体系的第二级，组合了service_id，目前asio中所有服务均承继与service_base。
“I/O对象”细化为basic_io_object及其派生类。basic_io_object是所有I/O对象的泛型，提供I/O对象与其对应服务的联系。再将图1.1进一步细化(关注网路I/O方面的一些类，其他方面的类未画出)：
(图1.2)
io_service的真正逻辑实现封装在内部桥接的类io_service_impl中，io_service_impl是一个typedef(在windows平台下是win_iocp_io_service，其他平台下是task_io_service)。io_service_impl就是一个承继于service_base的服务，在io_service初始化也就是其关联类service_registry初始化时被创建，再由io_service持有其引用。
从图中可以见到，承继于service_base的服务有：
strand_service：提供串行化多线程调用的功能
deadline_timer_service：提供定时器功能
stream_socket_service：提供流式socket相关功能
datagram_socket_service：提供报文式socket相关功能
seq_packet_socket_service：提供seq_packetsocket相关功能
raw_socket_service：提供原始套接字相关功能
socket_acceptor_service：提供端口窃听和接受顾客端联接相关功能
这种服务都是幕后英雄，对于用户而言是感知不到的，用户使用的都是其对应的I/O对象。
这种服务对应的I/O对象是：
io_service::strand
basic_deadline_timer
basic_stream_socket
basic_datagram_socket
basic_seq_packet_socket
basic_raw_socket
basic_socket_acceptor
除此之外，asio中还有并口通讯、信号处理等功能，在此不再一一赘言。
相关视频推荐
boost.asio是哪些？解决了网路编程中什么痛点？
手把手带你看mmorpg开源框架的网路模块封装
8个方面讲解io_uring，重构对异步io的理解
须要C/C++Linux服务器构架师学习资料加qun812855908获取（资料包括C/C++，Linux，golang技术，Nginx，ZeroMQ，MySQL，Redis，fastdfslinux c++定时器，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，解释器，DPDK，ffmpeg等），免费分享
3、流程剖析3.1常见流程剖析之一(Tcp异步联接)
我们用一个简单的demo剖析Tcp异步联接的流程：
1 #include
2 #include
3
4 // 异步连接回调函数
5 void on_connect(boost::system::error_code ec)
6 {
7 if (ec) // 连接失败, 输出错误码
8 std::cout << "async connect error:" << ec.message() << std::endl;
9 else // 连接成功
10 std::cout << "async connect ok!" << std::endl;
11 }
12
13 int main()
14 {
15 boost::asio::io_service ios; // 创建io_service对象
16 boost::asio::ip::tcp::endpoint addr(
17 boost::asio::ip::address::from_string("127.0.0.1"), 12345); // server端地址
18 boost::asio::ip::tcp::socket conn_socket(ios); // 创建tcp协议的socket对象
19 conn_socket.async_connect(addr, &on_connect); // 发起异步连接请求
20 ios.run(); // 调用io_service::run, 等待异步操作结果
21
22 std::cin.get();
23 return 0;
24 }这段代码中的异步联接恳求在asio源码中的序列图如下：
其中，basic_socket是个模板类，tcp合同中的socket的定义如下：
typedef basic_socket socket;reactor的定义如下：
#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
typedef class null_reactor reactor;
#elif defined(BOOST_ASIO_HAS_IOCP)
typedef class select_reactor reactor;
#elif defined(BOOST_ASIO_HAS_EPOLL)
typedef class epoll_reactor reactor;
#elif defined(BOOST_ASIO_HAS_KQUEUE)
typedef class kqueue_reactor reactor;
#elif defined(BOOST_ASIO_HAS_DEV_POLL)
typedef class dev_poll_reactor reactor;
#else
typedef class select_reactor reactor;
#endif在这个序列图中最值得注意的一点是：在windows平台下，异步联接恳求不是由Iocp处理的，而是由select模型处理的，这是与异步读写数据最大的不同之处。
3.2常见流程剖析之二(Tcp异步接受联接)
我们用一个简单的demo剖析Tcp异步联接的流程：
1 #include
2 #include
3 #include
4
5 // 异步连接回调函数
6 void on_accept(boost::system::error_code ec, boost::asio::ip::tcp::socket * socket_ptr)
7 {
8 if (ec) // 连接失败, 输出错误码
9 std::cout << "async accept error:" << ec.message() << std::endl;
10 else // 连接成功
11 std::cout << "async accept from (" <remote_endpoint() << ")" <close(), delete socket_ptr;
15 }
16
17 int main()
18 {
19 boost::asio::io_service ios; // 创建io_service对象
20 boost::asio::ip::tcp::endpoint addr(
21 boost::asio::ip::address::from_string("0.0.0.0"), 12345); // server端地址
22 boost::asio::ip::tcp::acceptor acceptor(ios, addr, false); // 创建acceptor对象
23 boost::asio::ip::tcp::socket * socket_ptr = new boost::asio::ip::tcp::socket(ios);
24 acceptor.async_accept(*socket_ptr
25 , boost::bind(&on_accept, boost::asio::placeholders::error, socket_ptr)); // 调用异步accept请求
26 ios.run(); // 调用io_service::run, 等待异步操作结果
27
28 std::cin.get();
29 return 0;
30 }这段代码中的异步联接恳求在asio源码中的序列图如下：
3.3常见流程剖析之三(Tcp异步读写数据)
我们仍然以上一节的事例为基础，扩充一个简单的demo剖析Tcp异步读写数据的流程：
1 #include
2 #include
3 #include
4 #include
5 #include
6
7 typedef boost::shared_ptr socket_ptr_t;
8 typedef boost::array buffer_t;
9 typedef boost::shared_ptr buffer_ptr_t;
10
11 // 异步读数据回调函数
12 void on_read(boost::system::error_code ec
13 , std::size_t len, socket_ptr_t socket_ptr, buffer_ptr_t buffer_ptr)
14 {
15 if (ec)
16 std::cout << "async write error:" << ec.message() << std::endl;
17 else
18 {
19 std::cout << "async read size:" << len;
20 std::cout << " info:" <begin(), len) << std::endl;
21
22 // auto release socket and buffer.
23 }
24 }
25
26 // 异步写数据回调函数
27 void on_write(boost::system::error_code ec
28 , std::size_t len, socket_ptr_t socket_ptr, buffer_ptr_t buffer_ptr)
29 {
30 if (ec)
31 std::cout << "async write error:" << ec.message() << std::endl;
32 else
33 {
34 std::cout << "async write size:" << len <async_read_some(boost::asio::buffer(buffer_ptr.get(), buffer_t::size())
36 , boost::bind(&on_read, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred
37 , socket_ptr, buffer_ptr));
38 }
39 }
40
41 // 异步连接回调函数
42 void on_accept(boost::system::error_code ec, socket_ptr_t socket_ptr)
43 {
44 if (ec) // 连接失败, 输出错误码
45 {
46 std::cout << "async accept error:" << ec.message() << std::endl;
47 }
48 else // 连接成功
49 {
50 std::cout << "async accept from (" <remote_endpoint() << ")" <begin(), buffer_t::size(), "abcdefg");
53 socket_ptr->async_write_some(boost::asio::buffer(buffer_ptr.get(), strlen((char*)buffer_ptr->begin()))
54 , boost::bind(&on_write, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred
55 , socket_ptr, buffer_ptr));
56 }
57 }
58
59 int main()
60 {
61 boost::asio::io_service ios; // 创建io_service对象
62 boost::asio::ip::tcp::endpoint addr(
63 boost::asio::ip::address::from_string("0.0.0.0"), 12345); // server端地址
64 boost::asio::ip::tcp::acceptor acceptor(ios, addr, false); // 创建acceptor对象
65 socket_ptr_t socket_ptr(new boost::asio::ip::tcp::socket(ios));
66 acceptor.async_accept(*socket_ptr
67 , boost::bind(&on_accept, boost::asio::placeholders::error, socket_ptr)); // 调用异步accept请求
68 ios.run(); // 调用io_service::run, 等待异步操作结果
69
70 std::cout << "press enter key...";
71 std::cin.get();
72 return 0;
73 } 这段代码中的异步联接恳求在asio源码中的序列图如下：
3.4常见流程剖析之四(Tcp强制关掉联接)
我们仍然以上一节的事例为基础，扩充一个简单的demo剖析Tcp强制关掉联接的流程：
1 #include
2 #include
3 #include
4 #include
5 #include
6
7 typedef boost::shared_ptr socket_ptr_t;
8 typedef boost::array buffer_t;
9 typedef boost::shared_ptr buffer_ptr_t;
10
11 // 异步读数据回调函数
12 void on_read(boost::system::error_code ec
13 , std::size_t len, socket_ptr_t socket_ptr, buffer_ptr_t buffer_ptr)
14 {
15 if (ec) // 连接失败, 输出错误码
16 {
17 std::cout << "async read error:" << ec.message() << std::endl;
18 }
19 }
20
21 // 异步写数据回调函数
22 void on_write(boost::system::error_code ec
23 , std::size_t len, socket_ptr_t socket_ptr, buffer_ptr_t buffer_ptr)
24 {
25 if (ec) // 连接失败, 输出错误码
26 {
27 std::cout << "async write error:" << ec.message() << std::endl;
28 }
29 }
30
31 // 异步连接回调函数
32 void on_accept(boost::system::error_code ec, socket_ptr_t socket_ptr)
33 {
34 if (ec) // 连接失败, 输出错误码
35 {
36 std::cout << "async accept error:" << ec.message() << std::endl;
37 }
38 else // 连接成功
39 {
40 std::cout << "async accept from (" <remote_endpoint() << ")" <begin(), buffer_t::size(), "abcdefg");
45 socket_ptr->async_write_some(boost::asio::buffer(buffer_ptr.get(), strlen((char*)buffer_ptr->begin()))
46 , boost::bind(&on_write, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred
47 , socket_ptr, buffer_ptr));
48 }
49
50 {
51 buffer_ptr_t buffer_ptr(new buffer_t);
52 socket_ptr->async_read_some(boost::asio::buffer(buffer_ptr.get(), buffer_t::size())
53 , boost::bind(&on_read, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred
54 , socket_ptr, buffer_ptr));
55 }
56
57 /// 强制关闭连接
58 socket_ptr->close(ec);
59 if (ec)
60 std::cout << "close error:" << ec.message() << std::endl;
61 }
62 }
63
64 int main()
65 {
66 boost::asio::io_service ios; // 创建io_service对象
67 boost::asio::ip::tcp::endpoint addr(
68 boost::asio::ip::address::from_string("0.0.0.0"), 12345); // server端地址
69 boost::asio::ip::tcp::acceptor acceptor(ios, addr, false); // 创建acceptor对象
70 socket_ptr_t socket_ptr(new boost::asio::ip::tcp::socket(ios));
71 acceptor.async_accept(*socket_ptr
72 , boost::bind(&on_accept, boost::asio::placeholders::error, socket_ptr)); // 调用异步accept请求
73 socket_ptr.reset();
74 ios.run(); // 调用io_service::run, 等待异步操作结果
75
76 std::cout << "press enter key...";
77 std::cin.get();
78 return 0;
79 } 这个事例中，接受到顾客端的联接后，立刻发起异步读恳求和异步写恳求，之后立刻强制关掉socket。
其中，强制关掉socket的恳求在asio源码中的序列图如下：
3.5常见流程剖析之五(Tcp高贵地关掉联接)
我们仍然以第三节的事例为基础，扩充一个简单的demo剖析Tcp高贵地关掉联接的流程：
1 #include
2 #include
3 #include
4 #include
5 #include
6
7 typedef boost::shared_ptr socket_ptr_t;
8 typedef boost::array buffer_t;
9 typedef boost::shared_ptr buffer_ptr_t;
10
11
12 // 异步读数据回调函数
13 void on_read(boost::system::error_code ec
14 , std::size_t len, socket_ptr_t socket_ptr, buffer_ptr_t buffer_ptr)
15 {
16 static int si = 0;
17 if (ec) // 连接失败, 输出错误码
18 {
19 std::cout << "async read(" << si++ << ") error:" << ec.message() <shutdown(boost::asio::socket_base::shutdown_receive, ec);
21 socket_ptr->close(ec);
22 if (ec)
23 std::cout << "close error:" << ec.message() << std::endl;
24 }
25 else
26 {
27 std::cout << "read(" << si++ << ") len:" << len <async_read_some(boost::asio::buffer(buffer_ptr.get(), buffer_t::size())
30 , boost::bind(&on_read, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred
31 , socket_ptr, buffer_ptr));
32 }
33 }
34
35 // 异步写数据回调函数
36 void on_write(boost::system::error_code ec
37 , std::size_t len, socket_ptr_t socket_ptr, buffer_ptr_t buffer_ptr)
38 {
39 if (ec) // 连接失败, 输出错误码
40 {
41 std::cout << "async write error:" << ec.message() <shutdown(boost::asio::ip::tcp::socket::shutdown_send, ec);
47 if (ec)
48 std::cout << "shutdown send error:" << ec.message() << std::endl;
49 }
50 }
51
52 // 异步连接回调函数
53 void on_accept(boost::system::error_code ec, socket_ptr_t socket_ptr)
54 {
55 if (ec) // 连接失败, 输出错误码
56 {
57 std::cout << "async accept error:" << ec.message() << std::endl;
58 }
59 else // 连接成功
60 {
61 std::cout << "async accept from (" <remote_endpoint() << ")" <async_read_some(boost::asio::buffer(buffer_ptr.get(), buffer_t::size())
66 , boost::bind(&on_read, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred
67 , socket_ptr, buffer_ptr));
68 }
69
70 {
71 buffer_ptr_t buffer_ptr(new buffer_t);
72 strcpy_s((char*)buffer_ptr->begin(), buffer_t::size(), "abcdefg");
73 socket_ptr->async_write_some(boost::asio::buffer(buffer_ptr.get(), strlen((char*)buffer_ptr->begin()))
74 , boost::bind(&on_write, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred
75 , socket_ptr, buffer_ptr));
76 }
77 }
78 }
79
80 int main()
81 {
82 boost::asio::io_service ios; // 创建io_service对象
83 boost::asio::ip::tcp::endpoint addr(
84 boost::asio::ip::address::from_string("0.0.0.0"), 12345); // server端地址
85 boost::asio::ip::tcp::acceptor acceptor(ios, addr, false); // 创建acceptor对象
86 socket_ptr_t socket_ptr(new boost::asio::ip::tcp::socket(ios));
87 acceptor.async_accept(*socket_ptr
88 , boost::bind(&on_accept, boost::asio::placeholders::error, socket_ptr)); // 调用异步accept请求
89 socket_ptr.reset();
90 ios.run(); // 调用io_service::run, 等待异步操作结果
91
92 std::cout << "press enter key...";
93 std::cin.get();
94 return 0;
95 }这个事例中，接收到顾客端的联接并向顾客端发送数据之后，先关掉socket的发送通道，之后等待socket接收缓冲区中的数据全部read下来之后，再关掉socket的接收通道。此时，socket的接收和发送通道均以关掉，任何进程都没法使用此socket收发数据，但其所占用的系统资源并未释放，底层发送缓冲区中的数据也不保证已全部发出，须要在此以后执行close操作便于释放系统资源。
若在释放系统资源前希望底层发送缓冲区中的数据仍然可以发出，则需在socket的linger属性中设置一个等待时间，便于有时间等待发送缓冲区中的数据发送完毕。但linger中的值绝对不是越大越好，这是由于其原理是操作系统帮忙保留socket的资源以等待其发送缓冲区中的数据发送完毕，假如远端socket的始终无法接收数据便会造成本地socket仍然等待下去，这对系统资源是极大的浪费。为此，在须要处理大量联接的服务端linux mint，linger的值一定不可过大。
4、ASIO中的类库概念(CONCEPTS)4.1Protocol(通讯合同)
Protocol，是asio在网路编程方面最重要的一个concept。在第一章中的levelX类图中可以见到，所有提供网路相关功能的服务和I/O对象都须要Protocol来确定一些细节。
Protocol的约束摘要如下：
1 class protocol
2 {
3 public:
4 /// Obtain an identifier for the type of the protocol.
5 int type() const;
6
7 /// Obtain an identifier for the protocol.
8 int protocol() const;
9
10 /// Obtain an identifier for the protocol family.
11 int family() const;
12
13 typedef ... endpoint;
14 typedef ... socket;
15 };符合Protocol约束的类须要提供type/protocol/family三个插口，分别返回合同类型/合同枚举/合同组枚举；还须要提供两个类型定义endpoint/socket，分别表示通讯合同一方的地址/承继于asio::basic_socket的类型。
目前，asio中符合Protocol约束的类有：stream_protocol，datagram_protocol，raw_protocol，seq_packet_protocol；
既符合Protocol约束，同时又符合InternetProtocol约束的类有：tcp(TCP合同)，udp(UDP合同)，icmp(ICMP合同)。
4.2InternetProtocol(网路通讯合同)
InternetProtocol，是Protocol的约束超集，在Protocol约束的基础上添加了几个新的约束。
InternetProtocol的约束摘要如下：
1 class InternetProtocol
2 {
3 public:
4 /// Construct to represent the IPv4 internet protocol.
5 static InternetProtocol v4();
6
7 /// Construct to represent the IPv6 internet protocol.
8 static InternetProtocol v6();
9
10 /// Obtain an identifier for the type of the protocol.
11 int type() const;
12
13 /// Obtain an identifier for the protocol.
14 int protocol() const;
15
16 /// Obtain an identifier for the protocol family.
17 int family() const;
18
19 typedef ... endpoint;
20 typedef ... socket;
21 typedef ... resolver;
22 };其中，type/protocol/family插口和endpoint/socket类型定义都是属于Protocol约束的部份红旗 linux，在此不再赘言。InternetProtocol相对于Protocol新增的约束有：v4/v6两个静态插口，分别返回IPv4/IPv6版本的网路通讯合同对象；类型定义resolver，表示承继于basic_resolver的类型。
4.3ConstBuffer(不可变缓冲区),ConstBufferSequence(不可变缓冲区序列),MutableBuffer(可变缓冲区),MutableBufferSequence(可变缓冲区序列)
ConstBuffer和MutableBuffer是asio中各类组件通用的缓冲区适配器concept，在asio中以const_buffer和mutable_buffer两个类实现。
ConstBuffer和MutableBuffer的约束摘要如下：
1 class ConstBuffer
2 {
3 private:
4 friend void const* boost::asio::detail::buffer_cast_helper(const ConstBuffer& b);
5 friend std::size_t boost::asio::detail::buffer_size_helper(const ConstBuffer& b);
6 };
7
8 class MutableBuffer
9 {
10 private:
11 friend void* boost::asio::detail::buffer_cast_helper(const MutableBuffer& b);
12 friend std::size_t boost::asio::detail::buffer_size_helper(const MutableBuffer& b);
13 };只需能通过buffer_cast_helper和buffer_size_helper这两个自由函数获取缓冲区首地址表针和缓冲区宽度即可。这两个concept没有哪些扩充的必要，因而asio中并未显式地提到，在后文中我们直接以她们当前的实现const_buffer和mutable_buffer这两个类取代。
ConstBufferSequence和MutableBufferSequence是const_buffer和mutable_buffer的容器约束。它们的约束摘要如下：
1 class ConstBufferSequence
2 {
3 public:
4 typedef const_buffer value_type;
5 typedef ... const_iterator;
6
7 const_iterator begin() const;
8 const_iterator end() const;
9 };
10
11 class MutableBufferSequence
12 {
13 public:
14 typedef mutable_buffer value_type;
15 typedef ... const_iterator;
16
17 const_iterator begin() const;
18 const_iterator end() const;
19 };ConstBufferSequence和MutableBufferSequence只需提供begin/end两个插口，返回相应的迭代器即可。
asio中，提供了const_buffer_1和mutable_buffer_1两个类，可以便捷地将单个的const_buffer和mutable_buffer封装为容器外形，使其符合ConstBufferSequence和MutableBufferSequence约束。
4.4Stream(流),AsyncReadStream(支持异步读操作的流),AsyncWriteStream(支持异步写操作的流),SyncReadStream(支持同步写操作的流),SyncWriteStream(支持同步写操作的流)
Stream，就是你们耳熟能详的“流”。
AsyncReadStream,AsyncWriteStream,SyncReadStream,SyncWriteStream四种concept是Stream的子集，在流的基础上添加一些插口。
Stream的约束摘要如下：
1 class Stream
2 {
3 public:
4 void close();
5 boost::system::error_code close(boost::system::error_code& ec);
6 };Stream的约束十分简单，只须要两个用于关掉流的close插口。
AsyncReadStream的约束摘要如下：
1 class AsyncReadStream
2 {
3 public:
4 template
5 void async_read_some(const MutableBufferSequence& buffers,
6 BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
7
8 void close();
9 boost::system::error_code close(boost::system::error_code& ec);
10 };AsyncReadStream在Stream的基础上降低了一个异步读数据的插口async_read_some，第一个参数buffers是一个符合MutableBufferSequence约束的对象linux c++定时器，第二个参数是异步操作的反弹函数。
AsyncWriteStream的约束摘要如下：
1 class AsyncWriteStream
2 {
3 public:
4 template
5 void async_write_some(const ConstBufferSequence& buffers,
6 BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
7
8 void close();
9 boost::system::error_code close(boost::system::error_code& ec);
10 };AsyncWriteStream在Stream的基础上降低了一个异步写数据的插口async_write_some，第一个参数buffers是一个符合ConstBufferSequence约束的对象，第二个参数是异步操作的反弹函数。
SyncReadStream的约束摘要如下：
1 class SyncReadStream
2 {
3 public:
4 template
5 void read_some(const MutableBufferSequence& buffers);
6
7 template
8 boost::system::error_code read_some(const MutableBufferSequence& buffers, boost::system::error_code& ec);
9
10 void close();
11 boost::system::error_code close(boost::system::error_code& ec);
12 };SyncReadStream在Stream的基础上降低了一个异步读数据的插口read_some，第一个参数buffers是一个符合MutableBufferSequence约束的对象。
SyncWriteStream的约束摘要如下：
1 class SyncWriteStream
2 {
3 public:
4 template
5 void write_some(const ConstBufferSequence& buffers);
6
7 template
8 boost::system::error_code write_some(const ConstBufferSequence& buffers, boost::system::error_code& ec);
9
10 void close();
11 boost::system::error_code close(boost::system::error_code& ec);
12 };SyncWriteStream在Stream的基础上降低了一个同步写数据的插口write_some，第一个参数buffers是一个符合ConstBufferSequence约束的对象。
5、泛型与面向对象的完美结合
本章中你将见到asio中对基类编程和面向对象编程两种范式的结合使用，为你打开多范式混和编程的房门。在这儿，子类编程和面向对象编程两种编程范式相辅相成、取长补短，发挥出了单一编程范式难以比拟的强悍威力，可谓多范式编程语言的应用标杆。
5.1ServiceConcept
Service，与basic_io_object结合时是一种子类Concept，与io_service和service_registry结合时是面向对象思想中service_base的泛化类型。
Service作为形参Concept时，其约束摘要如下：
1 class Service
2 {
3 public:
4 typedef ... implementation_type;
5
6 void construct(implementation_type& );
7 void destroy(implementation_type& );
8 io_service& get_io_service();
9 };其中，implementation_type是Service对应的I/O对象持有的句柄类型，basic_io_object在构造/析构时会调用construct/destroy插口注册/注销到Service中。
Service与io_service和service_registry结合时，要求其必须承继于service_base。service_base及其子类io_service::service的类摘要如下：
1 class io_service::service
2 : private noncopyable
3 {
4 public:
5 boost::asio::io_service& get_io_service();
6
7 protected:
8 service(boost::asio::io_service& owner);
9 virtual ~service();
10
11 private:
12 virtual void shutdown_service() = 0;
13
14 virtual void fork_service(boost::asio::io_service::fork_event event);
15
16 friend class boost::asio::detail::service_registry;
17 struct key
18 {
19 key() : type_info_(0), id_(0) {}
20 const std::type_info* type_info_;
21 const boost::asio::io_service::id* id_;
22 } key_;
23
24 boost::asio::io_service& owner_;
25 service * next_;
26 };
27
28 template
29 class service_base : public io_service::service
30 {
31 public:
32 static boost::asio::detail::service_id id;
33
34 service_base(boost::asio::io_service& io_service) : io_service::service(io_service) {}
35 };其中，Service在service_registry中是以侵入式的单数组储存的，io_service::service中成员next_即是指向下一个Service的表针。service_base类的模板参数Type即是Service的类型，Service在承继service_base时的写法大致如下：
1 class Service
2 : public service_base
3 {
4 };将两种约束结合，得到一个最简单的可以与I/O对象搭配使用的Service的写法如下：
1 class Service
2 : public service_base
3 {
4 public:
5 typedef ... implementation_type;
6
7 void construct(implementation_type&);
8 void destroy(implementation_type&);
9 io_service& get_io_service();
10 };5.2CSU(Core-Service-User构架)
第一章中单纯从面向对象的角度介绍过Asio的核心构架，本节不再局限于单一编程范式，从源码剖析开始探讨Asio的核心构架。
Asio的核心构架是由三大组件构成，其分别是：
这些由Core-Service-User三部份组成的构架，为行文便捷姑且简称为CSU。
在Asio的CSU构架中，io_service以及几个关联类和内部类饰演了Core的角色；之前提到的ServiceConcept约定了Service的扩充形式；本节以一个Service及其对应的I/O对象为例介绍CSU的实现。为了便于理解，将源码中用于实现CSU的部份摘要下来，忽视与CSU无关的代码，并做一些小幅度更改。
Core相关代码摘要:
1 class io_service
2 {
3 // 持有一个service_registry对象
4 service_registry * service_registry_;
5 };
6
7 // 返回ios中服务类型是Service的服务的引用
8 template Service& use_service(io_service& ios);
9
10 // 给ios添加服务svc
11 template void add_service(io_service& ios, Service* svc);
12
13 // 判断ios中是否有服务类型是Service的服务
14 template bool has_service(io_service& ios);
15
16 // 所有Service的根基类
17 class io_service::service
18 {
19 };
20
21 // 用于组合多个Service
22 class service_registry
23 {
24 io_service::service * service_list_;
25
26 private:
27 /// 以下三个函数是同名自由函数的真正实现
28 template Service& use_service();
29 template void add_service(Service* svc);
30 template bool has_service();
31 };
32
33 // 所有Service的直接父类，Type必须为Service自身类型。
34 template
35 class service_base
36 {
37 static service_id id;
38 };Service，以deadline_timer_service为例:
1 // 定时器服务
2 template <typename TimeType,
3 typename TimeTraits = boost::asio::time_traits >
4 class deadline_timer_service
5 {
6 private:
7 typedef detail::deadline_timer_service service_impl_type;
8
9 public:
10 typedef typename service_impl_type::implementation_type implementation_type;
11
12 /// Construct a new timer service for the specified io_service.
13 explicit deadline_timer_service(boost::asio::io_service& io_service)
14 : boost::asio::detail::service_base<
15 deadline_timer_service >(io_service),
16 service_impl_(io_service)
17 {
18 }
19
20 /// Construct a new timer implementation.
21 void construct(implementation_type& impl)
22 {
23 service_impl_.construct(impl);
24 }
25
26 /// Destroy a timer implementation.
27 void destroy(implementation_type& impl)
28 {
29 service_impl_.destroy(impl);
30 }
31
32 /// Cancel any asynchronous wait operations associated with the timer.
33 std::size_t cancel(implementation_type& impl, boost::system::error_code& ec)
34 {
35 return service_impl_.cancel(impl, ec);
36 }
37
38 /// Cancels one asynchronous wait operation associated with the timer.
39 std::size_t cancel_one(implementation_type& impl,
40 boost::system::error_code& ec)
41 {
42 return service_impl_.cancel_one(impl, ec);
43 }
44
45 /// Get the expiry time for the timer as an absolute time.
46 time_type expires_at(const implementation_type& impl) const
47 {
48 return service_impl_.expires_at(impl);
49 }
50
51 /// Set the expiry time for the timer as an absolute time.
52 std::size_t expires_at(implementation_type& impl,
53 const time_type& expiry_time, boost::system::error_code& ec)
54 {
55 return service_impl_.expires_at(impl, expiry_time, ec);
56 }
57
58 /// Get the expiry time for the timer relative to now.
59 duration_type expires_from_now(const implementation_type& impl) const
60 {
61 return service_impl_.expires_from_now(impl);
62 }
63
64 /// Set the expiry time for the timer relative to now.
65 std::size_t expires_from_now(implementation_type& impl,
66 const duration_type& expiry_time, boost::system::error_code& ec)
67 {
68 return service_impl_.expires_from_now(impl, expiry_time, ec);
69 }
70
71 // Perform a blocking wait on the timer.
72 void wait(implementation_type& impl, boost::system::error_code& ec)
73 {
74 service_impl_.wait(impl, ec);
75 }
76
77 // Start an asynchronous wait on the timer.
78 template
79 BOOST_ASIO_INITFN_RESULT_TYPE(WaitHandler,
80 void (boost::system::error_code))
81 async_wait(implementation_type& impl,
82 BOOST_ASIO_MOVE_ARG(WaitHandler) handler)
83 {
84 detail::async_result_init init(
86 BOOST_ASIO_MOVE_CAST(WaitHandler)(handler));
87
88 service_impl_.async_wait(impl, init.handler);
89
90 return init.result.get();
91 }
92
93 private:
94 // Destroy all user-defined handler objects owned by the service.
95 void shutdown_service()
96 {
97 service_impl_.shutdown_service();
98 }
99
100 // The platform-specific implementation.
101 service_impl_type service_impl_;
102 };User相关代码，以basic_deadline_timer为例:
1 template
2 class basic_io_object
3 {
4 public:
5 typedef IoObjectService service_type;
6 typedef typename service_type::implementation_type implementation_type;
7
8 boost::asio::io_service& get_io_service();
9
10 protected:
11 explicit basic_io_object(boost::asio::io_service& io_service)
12 : service_(&boost::asio::use_service(io_service))
13 {
14 service_->construct(implementation);
15 }
16
17 ~basic_io_object()
18 {
19 service_->destroy(implementation);
20 }
21
22 service_type& get_service()
23 {
24 return *service_;
25 }
26
27 const service_type& get_service() const
28 {
29 return *service_;
30 }
31
32 implementation_type& get_implementation()
33 {
34 return implementation;
35 }
36
37 const implementation_type& get_implementation() const
38 {
39 return implementation;
40 }
41
42 implementation_type implementation;
43
44 private:
45 basic_io_object(const basic_io_object&);
46 void operator=(const basic_io_object&);
47
48 IoObjectService* service_;
49 };
50
51 template <typename Time,
52 typename TimeTraits = boost::asio::time_traits,
53 typename TimerService = deadline_timer_service >
54 class basic_deadline_timer
55 : public basic_io_object
56 {
57 public:
58 /// 三个构造函数均需要io_service&
59 explicit basic_deadline_timer(boost::asio::io_service& io_service);
60 basic_deadline_timer(boost::asio::io_service& io_service, const time_type& expiry_time);
61 basic_deadline_timer(boost::asio::io_service& io_service, const duration_type& expiry_time);
62
63 ////////////////////////////////////////////////////
64 /// @{ 功能性接口
65 std::size_t cancel();
66 std::size_t cancel(boost::system::error_code& ec);
67 std::size_t cancel_one();
68 std::size_t cancel_one(boost::system::error_code& ec);
69
70 time_type expires_at() const;
71 std::size_t expires_at(const time_type& expiry_time);
72 std::size_t expires_at(const time_type& expiry_time, boost::system::error_code& ec);
73
74 duration_type expires_from_now() const;
75 std::size_t expires_from_now(const duration_type& expiry_time);
76 std::size_t expires_from_now(const duration_type& expiry_time, boost::system::error_code& ec);
77
78 void wait();
79 void wait(boost::system::error_code& ec);
80
81 template
82 BOOST_ASIO_INITFN_RESULT_TYPE(WaitHandler, void (boost::system::error_code))
83 async_wait(BOOST_ASIO_MOVE_ARG(WaitHandler) handler);
84 /// @}
85 /////////////////////////////////////////////////////
86 };在basic_deadline_timer和其对应服务deadline_timer_service的源码中可以很清晰的看见，她们都有名为
cancel/cancel_one/expires_at/expires_from_now/wait/async_wait的函数，这种是deadline_timer对外提供的功能插口；basic_deadline_timer类中的那些插口只是对deadline_timer_service中同名插口的封装。
在Asio的CSU构架中，用类库编程的方法约束Service和User，使她们拥有极强的扩充性；用面向对象的手段连结Core-Service-User三大组件，从用户的角度看，形成类似于“高内聚”的疗效，让用户可以以简单而统一的插口使用asio，毋须自行处理高难度的子类组件的组装工作。
六.扩充Asio（后续更新）七.基于Asio封装更易用的网路库bexio（后续更新）
