今天给各位分享Linux网站源码分享发布的知识，其中也会对linux制作网站进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
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(其他平台)等等服务。
&34;在这一层中可以理解为就是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<Type>，目前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，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK，ffmpeg等），免费分享
3、流程分析
3.1常见流程分析之一(Tcp异步连接)
我们用一个简单的demo分析Tcp异步连接的流程：
1include<boost/asio.hpp>\n3\n4//异步连接回调函数\n5voidon_connect(boost::system::error_codeec)\n6{\n7if(ec)//连接失败,输出错误码\n8std::cout<<&34;<<ec.message()<<std::endl;\n9else//连接成功\n10std::cout<<&34;<<std::endl;\n11}\n12\n13intmain()\n14{\n15boost::asio::io_serviceios;//创建io_service对象\n16boost::asio::ip::tcp::endpointaddr(\n17boost::asio::ip::address::from_string(&34;),12345);//server端地址\n18boost::asio::ip::tcp::socketconn_socket(ios);//创建tcp协议的socket对象\n19conn_socket.async_connect(addr,&on_connect);//发起异步连接请求\n20ios.run();//调用io_service::run,等待异步操作结果\n21\n22std::cin.get();\n23return0;\n24}
这段代码中的异步连接请求在asio源码中的序列图如下：
?其中，basic_socket是个模板类，tcp协议中的socket的定义如下：
typedefbasic_socket<tcp>socket;
reactor的定义如下：
elifdefined(BOOST_ASIO_HAS_IOCP)\ntypedefclassselect_reactorreactor;\nelifdefined(BOOST_ASIO_HAS_KQUEUE)\ntypedefclasskqueue_reactorreactor;\nelse\ntypedefclassselect_reactorreactor;\ninclude<iostream>\n2include<boost/bind.hpp>\n4\n5//异步连接回调函数\n6voidon_accept(boost::system::error_codeec,boost::asio::ip::tcp::socket*socket_ptr)\n7{\n8if(ec)//连接失败,输出错误码\n9std::cout<<&34;<<ec.message()<<std::endl;\n10else//连接成功\n11std::cout<<&34;<<socket_ptr->remote_endpoint()<<&34;<<std::endl;\n12\n13//断开连接,释放资源.\n14socket_ptr->close(),deletesocket_ptr;\n15}\n16\n17intmain()\n18{\n19boost::asio::io_serviceios;//创建io_service对象\n20boost::asio::ip::tcp::endpointaddr(\n21boost::asio::ip::address::from_string(&34;),12345);//server端地址\n22boost::asio::ip::tcp::acceptoracceptor(ios,addr,false);//创建acceptor对象\n23boost::asio::ip::tcp::socket*socket_ptr=newboost::asio::ip::tcp::socket(ios);\n24acceptor.async_accept(*socket_ptr\n25,boost::bind(&on_accept,boost::asio::placeholders::error,socket_ptr));//调用异步accept请求\n26ios.run();//调用io_service::run,等待异步操作结果\n27\n28std::cin.get();\n29return0;\n30}
这段代码中的异步连接请求在asio源码中的序列图如下：
3.3常见流程分析之三(Tcp异步读写数据)
我们依然以上一节的例子为基础，扩展一个简单的demo分析Tcp异步读写数据的流程：
\n1include<boost/asio.hpp>\n3include<boost/shared_ptr.hpp>\n534;asyncwriteerror:&34;asyncreadsize:&34;info:&34;asyncwriteerror:&34;asyncwritesize:&34;asyncaccepterror:&34;asyncacceptfrom(&34;)&34;abcdefg&34;0.0.0.0&34;pressenterkey…&include<iostream>\n2include<boost/bind.hpp>\n4include<boost/array.hpp>\n6\n7typedefboost::shared_ptr<boost::asio::ip::tcp::socket>socket_ptr_t;\n8typedefboost::array<char,128>buffer_t;\n9typedefboost::shared_ptr<buffer_t>buffer_ptr_t;\n10\n11//异步读数据回调函数\n12voidon_read(boost::system::error_codeec\n13,std::size_tlen,socket_ptr_tsocket_ptr,buffer_ptr_tbuffer_ptr)\n14{\n15if(ec)//连接失败,输出错误码\n16{\n17std::cout<<&34;<<ec.message()<<std::endl;\n18}\n19}\n20\n21//异步写数据回调函数\n22voidon_write(boost::system::error_codeec\n23,std::size_tlen,socket_ptr_tsocket_ptr,buffer_ptr_tbuffer_ptr)\n24{\n25if(ec)//连接失败,输出错误码\n26{\n27std::cout<<&34;<<ec.message()<<std::endl;\n28}\n29}\n30\n31//异步连接回调函数\n32voidon_accept(boost::system::error_codeec,socket_ptr_tsocket_ptr)\n33{\n34if(ec)//连接失败,输出错误码\n35{\n36std::cout<<&34;<<ec.message()<<std::endl;\n37}\n38else//连接成功\n39{\n40std::cout<<&34;<<socket_ptr->remote_endpoint()<<&34;<<std::endl;\n41\n42{\n43buffer_ptr_tbuffer_ptr(newbuffer_t);\n44strcpy_s((char*)buffer_ptr->begin(),buffer_t::size(),&34;);\n45socket_ptr->async_write_some(boost::asio::buffer(buffer_ptr.get(),strlen((char*)buffer_ptr->begin()))\n46,boost::bind(&on_write,boost::asio::placeholders::error,boost::asio::placeholders::bytes_transferred\n47,socket_ptr,buffer_ptr));\n48}\n49\n50{\n51buffer_ptr_tbuffer_ptr(newbuffer_t);\n52socket_ptr->async_read_some(boost::asio::buffer(buffer_ptr.get(),buffer_t::size())\n53,boost::bind(&on_read,boost::asio::placeholders::error,boost::asio::placeholders::bytes_transferred\n54,socket_ptr,buffer_ptr));\n55}\n56\n57///强制关闭连接\n58socket_ptr->close(ec);\n59if(ec)\n60std::cout<<&34;<<ec.message()<<std::endl;\n61}\n62}\n63\n64intmain()\n65{\n66boost::asio::io_serviceios;//创建io_service对象\n67boost::asio::ip::tcp::endpointaddr(\n68boost::asio::ip::address::from_string(&34;),12345);//server端地址\n69boost::asio::ip::tcp::acceptoracceptor(ios,addr,false);//创建acceptor对象\n70socket_ptr_tsocket_ptr(newboost::asio::ip::tcp::socket(ios));\n71acceptor.async_accept(*socket_ptr\n72,boost::bind(&on_accept,boost::asio::placeholders::error,socket_ptr));//调用异步accept请求\n73socket_ptr.reset();\n74ios.run();//调用io_service::run,等待异步操作结果\n75\n76std::cout<<&34;;\n77std::cin.get();\n78return0;\n79}
这个例子中，接受到客户端的连接后，立即发起异步读请求和异步写请求，然后立即强制关闭socket。
其中，强制关闭socket的请求在asio源码中的序列图如下：
3.5常见流程分析之五(Tcp优雅地关闭连接)
我们依然以第三节的例子为基础，扩展一个简单的demo分析Tcp优雅地关闭连接的流程：
1include<boost/asio.hpp>\n3include<boost/shared_ptr.hpp>\n534;asyncread(&34;)error:&34;closeerror:&34;read(&34;)len:&34;asyncwriteerror:&34;shutdownsenderror:&34;asyncaccepterror:&34;asyncacceptfrom(&34;)&34;abcdefg&34;0.0.0.0&34;pressenterkey…”;\n93std::cin.get();\n94return0;\n95}
这个例子中，接收到客户端的连接并向客户端发送数据以后，先关闭socket的发送通道，然后等待socket接收缓冲区中的数据全部read出来以后，再关闭socket的接收通道。此时，socket的接收和发送通道均以关闭，任何进程都无法使用此socket收发数据，但其所占用的系统资源并未释放，底层发送缓冲区中的数据也不保证已全部发出，需要在此之后执行close操作以便释放系统资源。
若在释放系统资源前希望底层发送缓冲区中的数据依然可以发出，则需在socket的linger属性中设置一个等待时间，以便有时间等待发送缓冲区中的数据发送完毕。但linger中的值绝对不是越大越好，这是因为其原理是操作系统帮忙保留socket的资源以等待其发送缓冲区中的数据发送完毕，如果远端socket的一直未能接收数据便会导致本地socket一直等待下去，这对系统资源是极大的浪费。因此，在需要处理大量连接的服务端，linger的值一定不可过大。
4、ASIO中的泛型概念(CONCEPTS)
4.1Protocol(通信协议)
Protocol，是asio在网络编程方面最重要的一个concept。在第一章中的levelX类图中可以看到，所有提供网络相关功能的服务和I/O对象都需要Protocol来确定一些细节。
Protocol的约束摘要如下：
1classprotocol\n2{\n3public:\n4///Obtainanidentifierforthetypeoftheprotocol.\n5inttype()const;\n6\n7///Obtainanidentifierfortheprotocol.\n8intprotocol()const;\n9\n10///Obtainanidentifierfortheprotocolfamily.\n11intfamily()const;\n12\n13typedef…endpoint;\n14typedef…socket;\n15};
符合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的约束摘要如下：
1classInternetProtocol\n2{\n3public:\n4///ConstructtorepresenttheIPv4internetprotocol.\n5staticInternetProtocolv4();\n6\n7///ConstructtorepresenttheIPv6internetprotocol.\n8staticInternetProtocolv6();\n9\n10///Obtainanidentifierforthetypeoftheprotocol.\n11inttype()const;\n12\n13///Obtainanidentifierfortheprotocol.\n14intprotocol()const;\n15\n16///Obtainanidentifierfortheprotocolfamily.\n17intfamily()const;\n18\n19typedef…endpoint;\n20typedef…socket;\n21typedef…resolver;\n22};
其中，type/protocol/family接口和endpoint/socket类型定义都是属于Protocol约束的部分，在此不再赘述。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的约束摘要如下：
1classConstBuffer\n2{\n3private:\n4friendvoidconst*boost::asio::detail::buffer_cast_helper(constConstBuffer&b);\n5friendstd::size_tboost::asio::detail::buffer_size_helper(constConstBuffer&b);\n6};\n7\n8classMutableBuffer\n9{\n10private:\n11friendvoid*boost::asio::detail::buffer_cast_helper(constMutableBuffer&b);\n12friendstd::size_tboost::asio::detail::buffer_size_helper(constMutableBuffer&b);\n13};
只需能通过buffer_cast_helper和buffer_size_helper这两个自由函数获取缓冲区首地址指针和缓冲区长度即可。这两个concept没有什么扩展的必要，因此asio中并未显式地提及，在后文中我们直接以他们当前的实现const_buffer和mutable_buffer这两个类替代。
ConstBufferSequence和MutableBufferSequence是const_buffer和mutable_buffer的容器约束。它们的约束摘要如下：
1classConstBufferSequence\n2{\n3public:\n4typedefconst_buffervalue_type;\n5typedef…const_iterator;\n6\n7const_iteratorbegin()const;\n8const_iteratorend()const;\n9};\n10\n11classMutableBufferSequence\n12{\n13public:\n14typedefmutable_buffervalue_type;\n15typedef…const_iterator;\n16\n17const_iteratorbegin()const;\n18const_iteratorend()const;\n19};
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的约束摘要如下：
1classStream\n2{\n3public:\n4voidclose();\n5boost::system::error_codeclose(boost::system::error_code&ec);\n6};
Stream的约束非常简单，只需要两个用于关闭流的close接口。
AsyncReadStream的约束摘要如下：
1classAsyncReadStream\n2{\n3public:\n4template<typenameMutableBufferSequence,typenameReadHandler>\n5voidasync_read_some(constMutableBufferSequence&buffers,\n6BOOST_ASIO_MOVE_ARG(ReadHandler)handler);\n7\n8voidclose();\n9boost::system::error_codeclose(boost::system::error_code&ec);\n10};
AsyncReadStream在Stream的基础上增加了一个异步读数据的接口async_read_some，第一个参数buffers是一个符合MutableBufferSequence约束的对象，第二个参数是异步操作的回调函数。
AsyncWriteStream的约束摘要如下：
1classAsyncWriteStream\n2{\n3public:\n4template<typenameConstBufferSequence,typenameWriteHandler>\n5voidasync_write_some(constConstBufferSequence&buffers,\n6BOOST_ASIO_MOVE_ARG(WriteHandler)handler);\n7\n8voidclose();\n9boost::system::error_codeclose(boost::system::error_code&ec);\n10};
AsyncWriteStream在Stream的基础上增加了一个异步写数据的接口async_write_some，第一个参数buffers是一个符合ConstBufferSequence约束的对象，第二个参数是异步操作的回调函数。
SyncReadStream的约束摘要如下：
1classSyncReadStream\n2{\n3public:\n4template<typenameMutableBufferSequence>\n5voidread_some(constMutableBufferSequence&buffers);\n6\n7template<typenameMutableBufferSequence>\n8boost::system::error_coderead_some(constMutableBufferSequence&buffers,boost::system::error_code&ec);\n9\n10voidclose();\n11boost::system::error_codeclose(boost::system::error_code&ec);\n12};
SyncReadStream在Stream的基础上增加了一个异步读数据的接口read_some，第一个参数buffers是一个符合MutableBufferSequence约束的对象。
SyncWriteStream的约束摘要如下：
1classSyncWriteStream\n2{\n3public:\n4template<typenameConstBufferSequence>\n5voidwrite_some(constConstBufferSequence&buffers);\n6\n7template<typenameConstBufferSequence>\n8boost::system::error_codewrite_some(constConstBufferSequence&buffers,boost::system::error_code&ec);\n9\n10voidclose();\n11boost::system::error_codeclose(boost::system::error_code&ec);\n12};
SyncWriteStream在Stream的基础上增加了一个同步写数据的接口write_some，第一个参数buffers是一个符合ConstBufferSequence约束的对象。
5、泛型与面向对象的完美结合
本章中你将看到asio中对泛型编程和面向对象编程两种范式的结合使用，为你打开多范式混合编程的大门。在这里，泛型编程和面向对象编程两种编程范式相辅相成、取长补短，发挥出了单一编程范式无法比拟的强大威力，堪称多范式编程语言的应用典范。
5.1ServiceConcept
Service，与basic_io_object结合时是一种泛型Concept，与io_service和service_registry结合时是面向对象思想中service_base的泛化类型。
Service作为泛型Concept时，其约束摘要如下：
1classService\n2{\n3public:\n4typedef…implementation_type;\n5\n6voidconstruct(implementation_type&);\n7voiddestroy(implementation_type&);\n8io_service&get_io_service();\n9};
其中，implementation_type是Service对应的I/O对象持有的句柄类型，basic_io_object在构造/析构时会调用construct/destroy接口注册/注销到Service中。
Service与io_service和service_registry结合时，要求其必须继承于service_base。service_base及其基类io_service::service的类摘要如下：
1classio_service::service\n2:privatenoncopyable\n3{\n4public:\n5boost::asio::io_service&get_io_service();\n6\n7protected:\n8service(boost::asio::io_service&owner);\n9virtual~service();\n10\n11private:\n12virtualvoidshutdown_service()=0;\n13\n14virtualvoidfork_service(boost::asio::io_service::fork_eventevent);\n15\n16friendclassboost::asio::detail::service_registry;\n17structkey\n18{\n19key():type_info_(0),id_(0){}\n20conststd::type_info*type_info_;\n21constboost::asio::io_service::id*id_;\n22}key_;\n23\n24boost::asio::io_service&owner_;\n25service*next_;\n26};\n27\n28template<typenameType>\n29classservice_base:publicio_service::service\n30{\n31public:\n32staticboost::asio::detail::service_id<Type>id;\n33\n34service_base(boost::asio::io_service&io_service):io_service::service(io_service){}\n35};
其中，Service在service_registry中是以侵入式的单链表存储的，io_service::service中成员next_即是指向下一个Service的指针。service_base类的模板参数Type即是Service的类型，Service在继承service_base时的写法大致如下：
1classService\n2:publicservice_base<Service>\n3{\n4};
将两种约束结合，得到一个最简单的可以与I/O对象搭配使用的Service的写法如下：
1classService\n2:publicservice_base<Service>\n3{\n4public:\n5typedef…implementation_type;\n6\n7voidconstruct(implementation_type&);\n8voiddestroy(implementation_type&);\n9io_service&get_io_service();\n10};
5.2CSU(Core-Service-User架构)
第一章中单纯从面向对象的角度介绍过Asio的核心架构，本节不再局限于单一编程范式，从源码分析开始剖析Asio的核心架构。
Asio的核心架构是由三大组件构成，其分别是：
让用户直接使用，为用户提供接口的组件，暂且称之为User;无需用户感知的，为User的接口提供实现的服务组件，称为Service;负责组合多个Service，并辅助User对象的实例化的核心组件，称为Core;
这种由Core-Service-User三部分组成的架构，为行文方便暂且简称为CSU。
在Asio的CSU架构中，io_service以及几个关联类和内部类扮演了Core的角色；之前提到的ServiceConcept约定了Service的扩展方式；本节以一个Service及其对应的I/O对象为例介绍CSU的实现。为了易于理解，将源码中用于实现CSU的部分摘要出来，忽略与CSU无关的代码，并做一些小幅度修改。
Core相关代码摘要:
1classio_service\n2{\n3//持有一个service_registry对象\n4service_registry*service_registry_;\n5};\n6\n7//返回ios中服务类型是Service的服务的引用\n8template<typenameService>Service&use_service(io_service&ios);\n9\n10//给ios添加服务svc\n11template<typenameService>voidadd_service(io_service&ios,Service*svc);\n12\n13//判断ios中是否有服务类型是Service的服务\n14template<typenameService>boolhas_service(io_service&ios);\n15\n16//所有Service的根基类\n17classio_service::service\n18{\n19};\n20\n21//用于组合多个Service\n22classservice_registry\n23{\n24io_service::service*service_list_;\n25\n26private:\n27///以下三个函数是同名自由函数的真正实现\n28template<typenameService>Service&use_service();\n29template<typenameService>voidadd_service(Service*svc);\n30template<typenameService>boolhas_service();\n31};\n32\n33//所有Service的直接父类，Type必须为Service自身类型。\n34template<typenameType>\n35classservice_base\n36{\n37staticservice_id<Type>id;\n38};
Service，以deadline_timer_service为例:
1//定时器服务\n2template<typenameTimeType,\n3typenameTimeTraits=boost::asio::time_traits<TimeType>>\n4classdeadline_timer_service\n5{\n6private:\n7typedefdetail::deadline_timer_service<traits_type>service_impl_type;\n8\n9public:\n10typedeftypenameservice_impl_type::implementation_typeimplementation_type;\n11\n12///Constructanewtimerserviceforthespecifiedio_service.\n13explicitdeadline_timer_service(boost::asio::io_service&io_service)\n14:boost::asio::detail::service_base<\n15deadline_timer_service<TimeType,TimeTraits>>(io_service),\n16service_impl_(io_service)\n17{\n18}\n19\n20///Constructanewtimerimplementation.\n21voidconstruct(implementation_type&impl)\n22{\n23service_impl_.construct(impl);\n24}\n25\n26///Destroyatimerimplementation.\n27voiddestroy(implementation_type&impl)\n28{\n29service_impl_.destroy(impl);\n30}\n31\n32///Cancelanyasynchronouswaitoperationsassociatedwiththetimer.\n33std::size_tcancel(implementation_type&impl,boost::system::error_code&ec)\n34{\n35returnservice_impl_.cancel(impl,ec);\n36}\n37\n38///Cancelsoneasynchronouswaitoperationassociatedwiththetimer.\n39std::size_tcancel_one(implementation_type&impl,\n40boost::system::error_code&ec)\n41{\n42returnservice_impl_.cancel_one(impl,ec);\n43}\n44\n45///Gettheexpirytimeforthetimerasanabsolutetime.\n46time_typeexpires_at(constimplementation_type&impl)const\n47{\n48returnservice_impl_.expires_at(impl);\n49}\n50\n51///Settheexpirytimeforthetimerasanabsolutetime.\n52std::size_texpires_at(implementation_type&impl,\n53consttime_type&expiry_time,boost::system::error_code&ec)\n54{\n55returnservice_impl_.expires_at(impl,expiry_time,ec);\n56}\n57\n58///Gettheexpirytimeforthetimerrelativetonow.\n59duration_typeexpires_from_now(constimplementation_type&impl)const\n60{\n61returnservice_impl_.expires_from_now(impl);\n62}\n63\n64///Settheexpirytimeforthetimerrelativetonow.\n65std::size_texpires_from_now(implementation_type&impl,\n66constduration_type&expiry_time,boost::system::error_code&ec)\n67{\n68returnservice_impl_.expires_from_now(impl,expiry_time,ec);\n69}\n70\n71//Performablockingwaitonthetimer.\n72voidwait(implementation_type&impl,boost::system::error_code&ec)\n73{\n74service_impl_.wait(impl,ec);\n75}\n76\n77//Startanasynchronouswaitonthetimer.\n78template<typenameWaitHandler>\n79BOOST_ASIO_INITFN_RESULT_TYPE(WaitHandler,\n80void(boost::system::error_code))\n81async_wait(implementation_type&impl,\n82BOOST_ASIO_MOVE_ARG(WaitHandler)handler)\n83{\n84detail::async_result_init<\n85WaitHandler,void(boost::system::error_code)>init(\n86BOOST_ASIO_MOVE_CAST(WaitHandler)(handler));\n87\n88service_impl_.async_wait(impl,init.handler);\n89\n90returninit.result.get();\n91}\n92\n93private:\n94//Destroyalluser-definedhandlerobjectsownedbytheservice.\n95voidshutdown_service()\n96{\n97service_impl_.shutdown_service();\n98}\n99\n100//Theplatform-specificimplementation.\n101service_impl_typeservice_impl_;\n102};
User相关代码，以basic_deadline_timer为例:
1template<typenameIoObjectService>\n2classbasic_io_object\n3{\n4public:\n5typedefIoObjectServiceservice_type;\n6typedeftypenameservice_type::implementation_typeimplementation_type;\n7\n8boost::asio::io_service&get_io_service();\n9\n10protected:\n11explicitbasic_io_object(boost::asio::io_service&io_service)\n12:service_(&boost::asio::use_service<IoObjectService>(io_service))\n13{\n14service_->construct(implementation);\n15}\n16\n17~basic_io_object()\n18{\n19service_->destroy(implementation);\n20}\n21\n22service_type&get_service()\n23{\n24return*service_;\n25}\n26\n27constservice_type&get_service()const\n28{\n29return*service_;\n30}\n31\n32implementation_type&get_implementation()\n33{\n34returnimplementation;\n35}\n36\n37constimplementation_type&get_implementation()const\n38{\n39returnimplementation;\n40}\n41\n42implementation_typeimplementation;\n43\n44private:\n45basic_io_object(constbasic_io_object&);\n46voidoperator=(constbasic_io_object&);\n47\n48IoObjectService*service_;\n49};\n50\n51template<typenameTime,\n52typenameTimeTraits=boost::asio::time_traits<Time>,\n53typenameTimerService=deadline_timer_service<Time,TimeTraits>>\n54classbasic_deadline_timer\n55:publicbasic_io_object<TimerService>\n56{\n57public:\n58///三个构造函数均需要io_service&\n59explicitbasic_deadline_timer(boost::asio::io_service&io_service);\n60basic_deadline_timer(boost::asio::io_service&io_service,consttime_type&expiry_time);\n61basic_deadline_timer(boost::asio::io_service&io_service,constduration_type&expiry_time);\n62\n63////////////////////////////////////////////////////\n64///@{功能性接口\n65std::size_tcancel();\n66std::size_tcancel(boost::system::error_code&ec);\n67std::size_tcancel_one();\n68std::size_tcancel_one(boost::system::error_code&ec);\n69\n70time_typeexpires_at()const;\n71std::size_texpires_at(consttime_type&expiry_time);\n72std::size_texpires_at(consttime_type&expiry_time,boost::system::error_code&ec);\n73\n74duration_typeexpires_from_now()const;\n75std::size_texpires_from_now(constduration_type&expiry_time);\n76std::size_texpires_from_now(constduration_type&expiry_time,boost::system::error_code&ec);\n77\n78voidwait();\n79voidwait(boost::system::error_code&ec);\n80\n81template<typenameWaitHandler>\n82BOOST_ASIO_INITFN_RESULT_TYPE(WaitHandler,void(boost::system::error_code))\n83async_wait(BOOST_ASIO_MOVE_ARG(WaitHandler)handler);\n84///@}\n85/////////////////////////////////////////////////////\n86};
在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（后续更新）
原文地址：boost.asio源码剖析
好了，本文到此结束，如果可以帮助到大家，还望关注本站哦！