碼上快樂

相關內容    簡體    繁體

Boost.Asio技術文檔

本文轉載自   查看原文   2014-05-13 22:05   2908    服務器技術

Christopher Kohlhoff

Copyright © 2003-2012 Christopher M. Kohlhoff

以Boost1.0的軟件授權進行發布(見附帶的LICENSE_1_0.txt文件或從http://www.boost.org/LICENSE_1_0.txt)

Boost.Asio是用於網絡和低層IO編程的跨平台C++庫,為開發者提供了C++環境下穩定的異步模型.

綜述

基本原理

應用程序與外界交互的方式有很多,可通過文件,網絡,串口或控制台.例如在網絡通信中,完成獨立的IO操作需要很長時間.對應用程序開發者提出了一個挑戰.

Boost.Asio 提供了管理需長時間運行操作的工具,但不必涉及到線程的並發模式和顯式鎖定.

Boost.Asio 庫使用C++來實現,提供如網絡編程等常用的操作系統接口. Boost.Asio實現了如下目標:

· 可移植性Portability.庫支持一系列的常用系統操作,具有穩定的跨平台特性.

· 可擴展性Scalability.庫可以幫助開發者構建數千並發連接的網絡應用程序.asio庫實現的每個系統操作都使用了最具擴展性的機制.

· 效率Efficiency.庫支持發散聚合IO(scatter-gather I/O)等技術,使應用程序盡量少的拷貝數據.

· 可以像BSD Sockets一樣通過API函數建立模型概念. BSD Socket API應用廣泛,有很多相關的程序庫.其他編程語言通常也使用其簡單的網絡API接口.出於這些原因, Boost.Asio同樣使用這種已存在的技術進行構建.

· 易於使用Ease of use.庫提供了工具箱而不是框架來降低新手入門門檻.使用最少時間投入來學習基本的規則和方針.而后,庫的使用者只需要理解用到的特定函數即可.

· 基於更多的抽象.Basis for further abstraction.asio庫提供了高層次的抽象允許其他開發者對庫進行擴展.例如,實現常用的HTTP協議.

雖然Boost.Asio一開始定位於網絡通信,但其異步IO的概念已經擴展到了如串口通信,文件描述符等其他操作系統的IO操作方面.

核心概念和功能

解析Boost.Asio

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執行其他類型的異步操作.

Proactor設計模式:無線程並發

Boost.Asio庫同時支持同步和異步操作.異步支持基於Proactor設計模式.下面討論這種方式與同步操作及Reactor方式相比的優缺點.

Proactor和Boost.Asio

現在討論Proactor不依賴於平台細節的特性.

Proactor 設計模式

— 異步操作:定義一個異步執行操作,如Socket異步讀寫.

— 異步操作處理器:執行異步操作,並在操作完成后執行完成事件隊列中的隊列事件.從更高層次上說,服務端的stream_socket_service 就是一個異步操作處理器.

— 完成事件隊列:存放完成事件,這些事件會被異步事件信號分離器移出隊列.

— 完成句柄:異步操作完成后執行的函數.這是一個函數對象,通常使用boost::bind創建.

— 異步事件信號分離器:在完成事件隊列中阻塞等待事件,受信后向調用者返回完成事件.

— Proactor :調用異步事件信號分離器將相應的處理事件移出隊列,並為這個事件分配一個完成句柄(如調用函數對象).這個功能封裝在io_service類中.

— 初始化器: 執行特定程序代碼啟動異步操作.初始化器通過如basic_stream_socket等高層次接口與異步操作處理器交互,並返回stream_socket_service等類型的服務端代理.

使用Reactor的實現

在很多平台上Boost.Asio按照Reactor機制實現Proactor設計模式,如select,epoll或kqueue等.相對於Proactor,其實現方式如下:

— 異步操作處理器:Reactor使用select,epoll或kqueue機制實現.如果reactor指示運行操作的資源已經就位,處理器執行異步操作並在完成事件隊列中插入相應的完成句柄.

— 完成事件隊列:存放完成句柄的鏈表(如函數對象).

— 異步事件信號分離器:在事件或條件變量上等待,直到完成事件隊列中的完成句柄可用.

實現Windows的重疊IO

在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准備讀或寫時才需要緩沖區空間.

線程和Boost.Asio

線程安全

通常在並發操作中使用相互獨立的局部對象是安全的,但並發操作中使用同一個全局對象就不安全了.然而如io_service 等類型可以保證並發操作中使用同一個對象也是安全的.

線程池

在多個線程中調用io_service::run()函數,就可以創建一個包含這些線程的線程池,其中的線程在異步操作完成后調用完成句柄.也可通過調用io_service::post()實現橫跨整個線程池的任意計算任務來達到相同的目的.

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

內部線程

這個庫的特定平台實現會創建幾個內部線程來模擬異步操作.同時,這些線程對庫用戶是不可見的.這些線程特性:

  • 不會直接調用用戶的代碼
  • 阻塞所有信號

使用如下擔保來實現:

  • 異步完成句柄只會由調用io_service::run()的線程來調用.

因此,由庫的使用者來建立和管理投遞通知的線程.

原因:

  • 在單線程中調用io_service::run(),用戶代碼避免了復雜的線程同步控制.例如,ASIO庫用戶可以使用單線程實現伸縮性良好的服務端(特定用戶觀點).
  • 線程啟動后在其他應用程序代碼執行前,ASIO庫用戶需要在線程中執行一些簡短的初始化操作.例如在線程中調用微軟的COM操作之前必須調用CoInitializeEx.
  • 將ASIO庫接口與線程的創建和管理進行了解耦,確保可在不支持線程的平台中進行調用.

Strands:無顯式鎖定的線程

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支持分散聚合操作,需要一個或多個緩沖區:

  • 一個分散讀(scatter-read)接收數據並存入多緩沖區.
  • .一個聚合寫(gather-write)傳輸多緩沖區中的數據.

因此需要一個抽象概念代表緩沖區集合.為此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.目的是提供了不透明的連續內存概念:

  • 類型轉換上同std::pair.即mutable_buffer可以轉換為const_buffer ,但反之不成立.
  • 可防止緩沖區溢出.對於一個緩沖區實例,用戶只能創建另外一個緩沖區來代表同樣的內存序列或子序列.為了更加安全,ASIOI庫也提供了從數組(如boost::array 或 std::vector,或std::string)中自動計算緩沖區大小的機制.
  • 必須明確的調用buffer_cast函數進行類型轉換.應用程序中通常不必如此,但在ASIO庫的實現中將原始內存數據傳遞給底層的操作系統函數時必須如此.

最后將多個緩沖區存入一個容器中就可以傳遞給分散聚合操作了.(如read()或write()).為了使用std::vector, std::list, std::vector 或 boost::array等容器而定義了MutableBufferSequence和ConstBufferSequence概念.

Streambuf與IoStream整合

類boost::asio::basic_streambuf從std::basic_streambuf繼承,將輸入輸出流與一個或多個字符數組類型的對象相關聯,其中的每個元素可以存儲任意值.這些字符數組對象是內部的streambuf對象,但通過直接存取數組中的元素使其可用於IO操作,如在socket中發送或接收:

  • streambuf 的輸入序列可以通過data()成員函數獲取.函數的返回值滿足ConstBufferSequence的要求.
  • streambuf 的輸出序列可以通過prepare()成員函數獲取.函數的返回值滿足MutableBufferSequence的要求.
  • 調用commit()成員函數將數據從前端的輸出序列傳遞到后端的輸入序列.
  • 調用consume()成員函數從輸入序列中移除數據.

streambuf 構造函數接收一個size_t的參數指定輸入序列和輸出序列大小的總和.對於任何操作,如果成功,增加內部數據量,超過這個大小限制會拋出std::length_error異常.

遍歷緩沖區序列的字節

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操作模型的對象需要模擬如下幾個操作:

  • SyncReadStream, 調用成員函數read_some()執行同步讀操作.
  • AsyncReadStream, 調用成員函數async_read_some()執行異步讀操作.
  • SyncWriteStream, 調用成員函數write_some()執行同步寫操作.
  • AsyncWriteStream, 調用成員函數async_write_some()執行異步寫操作.

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

通常程序需要傳遞指定數量的字節數據.啟動操作后就會發生短讀或短寫,直到所有數據傳輸完畢.Boost.Asio提供了通用函數來自動完成這些操作: read(), async_read(), write() 和 async_write().

為什么EOF是一個錯誤

  • 流終止會導致read, async_read, read_until or async_read_until 函數違反約定.如要讀取N個字節,但由於遇到EOF而提前結束.
  • EOF錯誤可以區分流終止和成功讀取0個字節.

 

Reactor風格操作

有時應用程序必須整合第三方的庫來實現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

程序進入了第n個句柄.<description>描述句柄參數.

<n

程序退出第n個句柄.

!n

程序由於異常退出第n個句柄.

~n

第n個句柄沒有執行就被銷毀了.通常是由於io_service銷毀時異步操作還沒有完成.

n*m

第n個句柄創建了一個生成第m個完成句柄的新異步操作.<description>描述什么異步操作被啟動.

n

第n個句柄執行其他操作.<description>顯示調用了哪些函數.通常只記錄close()和cancel()操作,因為其影響了異步操作掛起狀態.

當<description>顯示同步或異步操作,格式為<object-type>@<pointer>.<operation>. 並以逗號間隔來顯示執行句柄的參數和值.

如上所示,每個句柄都由唯一的數字進行標識.句柄跟蹤輸出的句柄編號是0的,表示操作不是這些句柄執行的.

可視化

句柄跟蹤輸出可以使用包含在handlerviz.pl中的工具進行處理,創建可視化的界面.

網絡

TCP,UDP和ICMP

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

TCP客戶端

使用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客戶端可以使用connect()和async_connect()函數建立連接.這個操作將嘗試列表中的每個端點直到Socket連接成功為止.例如,簡單的調用:

ip::tcp::socket socket(my_io_service);
boost::asio::connect(socket, resolver.resolve(query));

將同時嘗試所有端點直到找到連接成功.同樣異步操作的方式為:

boost::asio::async_connect(socket_, iter,
    boost::bind(&client::handle_connect, this,
      boost::asio::placeholders::error));
 
// ...
 
void handle_connect(const error_code& error)
{
  if (!error)
  {
    // Start read or write operations.
  }
  else
  {
    // Handle error.
  }
}

當特定端點可用,socket創建並連接.方式為:

ip::tcp::socket socket(my_io_service);
socket.connect(endpoint);

使用成員函數receive(),async_receive(),send() 或 async_send()可將數據讀於或寫到TCP連接的Socket上.然而為了快速的讀寫操作,通常使用read(),async_read(),write()和async_write()函數進行操作.

TCP服務

程序使用接收器來接收到達的TCP連接:

ip::tcp::acceptor acceptor(my_io_service, my_endpoint);
...
ip::tcp::socket socket(my_io_service);
acceptor.accept(socket);

當成功接收一個socket連接(向如上例中的TCP客戶端),就可以在其上讀取或寫入數據了.

UDP

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);

使用成員函數receive_from(),async_receive_from(),send_to() 或 async_send_to()可在無連接的UPD Socket上讀出或寫入數據.對於連接的UDP Socket,可使用receive(),async_receive(),send() 或 async_send()成員函數.

ICMP

如同TCP和UPD一樣,ICMP也是用resolver解析主機名稱:

ip::icmp::resolver resolver(my_io_service);
ip::icmp::resolver::query query("localhost", "");
ip::icmp::resolver::iterator iter = resolver.resolve(query);
...

ICMP Socket可能綁定到本地端點.如下代碼創建IPv6版本的ICMP Socket,並綁定到任意的地址:

ip::icmp::endpoint endpoint(ip::icmp::v6(), 0);
ip::icmp::socket socket(my_io_service, endpoint);

ICMP不必指定端口號.

使用成員函數receive_from(),async_receive_from(),send_to() 或 async_send_to()在無連接的ICMP上讀出或寫入數據.

其他協議

其他Socket協議的支持(如藍牙或IRCOMM)可按協議要求進行實現.

Socket IO流

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,不要用於這樣的代碼版本.

BSD Socket API和Boost.Asio

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的對比:

BSD Socket API 元素

Boost.Asio中等價內容

Socket描述符-int (POSIX)或SOCKET (Windows)

TCP: ip::tcp::socket, ip::tcp::acceptor

UDP: ip::udp::socket

basic_socket,basic_stream_socket,basic_datagram_socket,basic_raw_socket

in_addr, in6_addr

ip::address,ip::address_v4,ip::address_v6

sockaddr_in, sockaddr_in6

TCP: ip::tcp::endpoint

UDP: ip::udp::endpoint

ip::basic_endpoint

accept()

TCP: ip::tcp::acceptor::accept()

basic_socket_acceptor::accept()

bind()

TCP: ip::tcp::acceptor::bind(), ip::tcp::socket::bind()

UDP: ip::udp::socket::bind()

basic_socket::bind()

close()

TCP: ip::tcp::acceptor::close(), ip::tcp::socket::close()

UDP: ip::udp::socket::close()

basic_socket::close()

connect()

TCP: ip::tcp::socket::connect()

UDP: ip::udp::socket::connect()

basic_socket::connect()

getaddrinfo(), gethostbyaddr(), gethostbyname(), getnameinfo(), getservbyname(), getservbyport()

TCP: ip::tcp::resolver::resolve(), ip::tcp::resolver::async_resolve()

UDP: ip::udp::resolver::resolve(), ip::udp::resolver::async_resolve()

ip::basic_resolver::resolve(),ip::basic_resolver::async_resolve()

gethostname()

ip::host_name()

getpeername()

TCP: ip::tcp::socket::remote_endpoint()

UDP: ip::udp::socket::remote_endpoint()

basic_socket::remote_endpoint()

getsockname()

TCP: ip::tcp::acceptor::local_endpoint(), ip::tcp::socket::local_endpoint()

UDP: ip::udp::socket::local_endpoint()

basic_socket::local_endpoint()

getsockopt()

TCP: ip::tcp::acceptor::get_option(), ip::tcp::socket::get_option()

UDP: ip::udp::socket::get_option()

basic_socket::get_option()

inet_addr(), inet_aton(), inet_pton()

ip::address::from_string(),ip::address_v4::from_string(),ip_address_v6::from_string()

inet_ntoa(), inet_ntop()

ip::address::to_string(),ip::address_v4::to_string(),ip_address_v6::to_string()

ioctl()

TCP: ip::tcp::socket::io_control()

UDP: ip::udp::socket::io_control()

basic_socket::io_control()

listen()

TCP: ip::tcp::acceptor::listen()

basic_socket_acceptor::listen()

poll(), select(), pselect()

io_service::run(),io_service::run_one(),io_service::poll(),io_service::poll_one()

注意:包括異步操作.

readv(), recv(), read()

CP: ip::tcp::socket::read_some(), ip::tcp::socket::async_read_some(), ip::tcp::socket::receive(), ip::tcp::socket::async_receive()

UDP: ip::udp::socket::receive(), ip::udp::socket::async_receive()

basic_stream_socket::read_some(),basic_stream_socket::async_read_some(),basic_stream_socket::receive(),basic_stream_socket::async_receive(),basic_datagram_socket::receive(),basic_datagram_socket::async_receive()

recvfrom()

UDP: ip::udp::socket::receive_from(), ip::udp::socket::async_receive_from()

basic_datagram_socket::receive_from(),basic_datagram_socket::async_receive_from()

send(), write(), writev()

TCP: ip::tcp::socket::write_some(), ip::tcp::socket::async_write_some(), ip::tcp::socket::send(), ip::tcp::socket::async_send()

UDP: ip::udp::socket::send(), ip::udp::socket::async_send()

basic_stream_socket::write_some(),basic_stream_socket::async_write_some(),basic_stream_socket::send(),basic_stream_socket::async_send(),basic_datagram_socket::send(),basic_datagram_socket::async_send()

sendto()

UDP: ip::udp::socket::send_to(), ip::udp::socket::async_send_to()

basic_datagram_socket::send_to(),basic_datagram_socket::async_send_to()

setsockopt()

TCP: ip::tcp::acceptor::set_option(), ip::tcp::socket::set_option()

UDP: ip::udp::socket::set_option()

basic_socket::set_option()

shutdown()

TCP: ip::tcp::socket::shutdown()

UDP: ip::udp::socket::shutdown()

basic_socket::shutdown()

sockatmark()

TCP: ip::tcp::socket::at_mark()

basic_socket::at_mark()

socket()

TCP: ip::tcp::acceptor::open(), ip::tcp::socket::open()

UDP: ip::udp::socket::open()

basic_socket::open()

socketpair()

local::connect_pair()

注意:僅適合POSIX操作系統.

定時器

長時間運行的操作通常都會設置一個最終的完成期限.這個最終期限可以是使用絕對時間來表示,但通常使用相對時間.

一個簡單的范例,在相對時間內執行等待異步操作:

io_service i;
...
deadline_timer t(i);
t.expires_from_now(boost::posix_time::seconds(5));
t.wait();

通常,程序會基於計時器來執行異步等待操作:

void handler(boost::system::error_code ec) { ... }
...
io_service i;
...
deadline_timer t(i);
t.expires_from_now(boost::posix_time::milliseconds(400));
t.async_wait(handler);
...
i.run();

定時器相關聯的超時期限可以是相對時間:

boost::posix_time::time_duration time_until_expiry
  = t.expires_from_now();

或使用絕對時間:

deadline_timer t2(i);
t2.expires_at(t.expires_at() + boost::posix_time::seconds(30));

串口

Boost.Asio包含用靈活的方式創建和操作串口的類.例如,打開串口的代碼:

serial_port port(my_io_service, name);

name是如Windows中的"COM1",及POSIX平台下的"/dev/ttyS0".

打開后,串口就可以向流一樣使用了.既這個對象可以用於async_read(),write(),async_write(),read_until() 或async_read_until()函數.

串口實現中還包括配置串口波特率,流控制,奇偶校驗,停止位和字符數量等可選類.

注意

串口可用於所有POSIX平台.Windows中串口通信需要在編譯期將IO完成端口激活.程序可以測試BOOST_ASIO_HAS_SERIAL_PORTS宏來檢查Windows系統是否支持串口操作.

信號處理

Boost.Asio通過signal_set類實現信號處理.程序可以向集合中加入一個或多個信號,而后執行asyn_wait()操作.當其中一個信號發生時執行特定的事件處理函數.同一個信號可注冊在多個singal_set對象中,但這些信號只能用於Boost.Asio .

void handler(
    const boost::system::error_code& error,
    int signal_number)
{
  if (!error)
  {
    // A signal occurred.
  }
}
 
...
 
// Construct a signal set registered for process termination.
boost::asio::signal_set signals(io_service, SIGINT, SIGTERM);
 
// Start an asynchronous wait for one of the signals to occur.
signals.async_wait(handler);

信號處理也可在Windows中使用,與VC++運行時庫映射到控制台的事件如Ctrl+C等價.

POSIX特有功能

UNIX領域的Socket

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));

而后進行同步或異步讀寫流.即對象可用於read(),async_read(),write(),async_write(),read_until() 或async_read_until()等函數.

注意

POSIX流描述符僅在支持平台上編譯時激活.程序可以檢查BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR宏查詢是否支持.

Fork

Boost.Asio 支持程序使用fork()系統調用.程序可以在適當時間調用io_service.notify_fork(),Boost.Asio可重新創建一個內部的文件描述符(如使用"self-pipe trick"描述符技巧激活反應器(reactor)).通知用法如下:

io_service_.notify_fork(boost::asio::io_service::fork_prepare);
if (fork() == 0)
{
  io_service_.notify_fork(boost::asio::io_service::fork_child);
  ...
}
else
{
  io_service_.notify_fork(boost::asio::io_service::fork_parent);
  ...
}

用戶定義服務可以重寫io_service::service::fork_service()虛函數有意制造fork操作.

注意所有Boost.Asio的公共API函數可訪問的文件描述符(如basic_socket<>, posix::stream_descriptor下的描述符)在fork期間不會更改.這需要程序按需要進行管理.

Windows特有功能

面向流的句柄

Boost.Asio 包含允許在Windows句柄上執行異步讀或寫操作的類,如命名管道.

例如,在命名管道上執行異步操作,創建如下對象:

HANDLE handle = ::CreateFile(...);
windows::stream_handle pipe(my_io_service, handle);

而后使用同步或異步方式讀寫流.即對象可用於read(),async_read(),write(),async_write(),read_until() 或async_read_until()函數.

句柄相對的內核對象必須支持IO完成端口(命名管道支持,但匿名管道和控制台流不支持).

注意

Windows句柄流只能在編譯期激活,而且必須只用IO完成端口作為后台處理(默認).可使用BOOST_ASIO_HAS_WINDOWS_STREAM_HANDLE宏檢測.

隨機存取句柄

Boost.Asio提供特定的類實現在規則文件相關句柄上執行異步讀寫操作.

例如,在文件上執行異步操作代碼:

HANDLE handle = ::CreateFile(...);
windows::random_access_handle file(my_io_service, handle);

可以通過成員函數read_some_at(), async_read_some_at(), write_some_at() 或 async_write_some_at()來讀出或寫入數據.然而,和流上的等價函數(read_some()等)一樣,這些函數只需要在單個操作中傳遞一個或多個字節.因此創建了read_at(),async_read_at(),write_at() 和 async_write_at()函數,內部重復調用相應的*_some_at()函數直到所有數據傳遞完畢為止.

注意

Windows隨機讀取句柄只能在編譯期激活,而且后台使用IO完成端口進行處理才可用.可使用BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE宏來檢測.

對象句柄

Boost.Asio提供Windows特有的類實現在內核對象句柄上進行異步等待的操作:

  • 修改通知
  • 控制台輸入
  • 事件
  • 內存資源通知
  • 進程
  • 信號量
  • 線程
  • 等待定時器

例如,在事件上執行異步操作,創建如下對象:

HANDLE handle = ::CreateEvent(...);
windows::object_handle file(my_io_service, handle);

wait()和async_wait()成員函數用於等待內核對象受信.

注意

Windows對象句柄需要在編譯期激活.可使用BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE宏檢查.

SSL

Boost.Asio 包括對SSL支持的類和類模板.這些類可以在通信時將已存在的流(如TCP Socket)進行加密.

在創建加密流前,應用程序必須構造SSL上下文對象.這個對象中通常設置了如驗證模式,證書文件等SLL選項.例如,客戶端初始化代碼如下:

ssl::context ctx(ssl::context::sslv23);
ctx.set_verify_mode(ssl::verify_peer);
ctx.load_verify_file("ca.pem");

在TCP Socket下使用SSL:

ssl::stream<ip::tcp::socket> ssl_sock(my_io_service, ctx);

執行特定的Socket操作,如建立遠程連接或接收連接,底層的Socket必須使用ssl::stream模板的lowest_layer()成員函數來獲取:

ip::tcp::socket::lowest_layer_type& sock = ssl_sock.lowest_layer();
sock.connect(my_endpoint);

有時底層的流對象的生命期要比SSL流長,這時模板參數需要引用流類型:

ip::tcp::socket sock(my_io_service);
ssl::stream<ip::tcp::socket&> ssl_sock(sock, ctx);

SSL的加密連接握手需要在傳輸或接收數據前進行.可通過ssl::stream模板的handshake()或async_handshake()成員函數建立連接.

連接后,SSL流對象即可向同步或異步讀寫流一樣的方式使用了.即對象可用於read(),async_read(),write(),async_write(),read_until() 或 async_read_until()函數.

證書驗證

Boost.Asio 提供各種方法來配置SSL證書驗證:

簡單情況下證書驗證規則為RFC2818(HTTPS下證書驗證), Boost.Asio 提供一個可重用的證書驗證回調函數對象:

下例演示用HTTPS的方式驗證遠程主機的證書:

using boost::asio::ip::tcp;
namespace ssl = boost::asio::ssl;
typedef ssl::stream<tcp::socket> ssl_socket;
 
// Create a context that uses the default paths for
// finding CA certificates.
ssl::context ctx(ssl::context::sslv23);
ctx.set_default_verify_paths();
 
// Open a socket and connect it to the remote host.
boost::asio::io_service io_service;
ssl_socket sock(io_service, ctx);
tcp::resolver resolver(io_service);
tcp::resolver::query query("host.name", "https");
boost::asio::connect(sock.lowest_layer(), resolver.resolve(query));
sock.lowest_layer().set_option(tcp::no_delay(true));
 
// Perform SSL handshake and verify the remote host's
// certificate.
sock.set_verify_mode(ssl::verify_peer);
sock.set_verify_callback(ssl::rfc2818_verification("host.name"));
sock.handshake(ssl_socket::client);
 
// ... read and write as normal ...

SSL和線程

SSL流對象在無鎖定的情況下執行.因此,異步執行SSL都需要隱式或顯式的應用strand.注意這意味着在單線程程序中不需同步控制(不必使用鎖).

注意

OpenSSL需要Boost.Asio的SSL支持.當應用程序使用未由Boost.Asio包裝的OpenSSL功能時,底層的OpenSSL類可通過調用ssl::context::native_handle() 或ssl::stream::native_handle()獲得.

C++2011支持

可移動IO對象

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可以使用可變參模板實現basic_socket_streambuf::connect()和basic_socket_iostream::connect()函數.

可變參模板支持在g++4.3及以后版本中的編譯期添加-std=c++0x 或 -std=gnu++0x編譯選項會自動激活.可使用BOOST_ASIO_DISABLE_VARIADIC_TEMPLATES宏禁用,使用BOOST_ASIO_HAS_VARIADIC_TEMPLATES宏激活.

數組容器

由於標准庫提供了std::array<>,Boost.Asio:

G++4.3及以后版本中加上-std=c++0x 或 -std=gnu++0x編譯選項即可自動激活std::array<>,同時VC++10也支持.使用BOOST_ASIO_DISABLE_STD_ARRAY宏禁用,或BOOST_ASIO_HAS_STD_ARRAY宏激活.

原語

Boost.Asio的實現相對於boost::detail::atomic_count優先使用std::atomic<>.

在g++4.5及以后版本中加入-std=c++0x 或 -std=gnu++0x編譯選項即可激活標准的原語整數模板.可使用BOOST_ASIO_DISABLE_STD_ATOMIC宏禁用,或BOOST_ASIO_HAS_STD_ATOMIC宏啟用.

共享指針

Boost.Asio 優先使用std::shared_ptr<>和std::weak_ptr<>.

在g++4.3及以后版本中編譯期添加編譯選項則會自動激活智能指針,MC++10也同樣.可定義BOOST_ASIO_DISABLE_STD_SHARED_PTR宏禁用,用BOOST_ASIO_HAS_STD_SHARED_PTR宏激活.

Chrono

Boost.Asio基於std::chrono機制通過basic_waitable_timer類模板提供了基本的定時器功能.system_timer,steady_timer 和 high_resolution_timer分別使用system_clock, steady_clock 和 high_resolution_clock標准時鍾.

g++4.6級以后版本添加-std=c++0x 或 -std=gnu++0x編譯選項即可自動支持std::chrono.(注意,g++中使用monotonic_clock替代steady_clock.)使用BOOST_ASIO_DISABLE_STD_CHRONO宏禁用, BOOST_ASIO_HAS_STD_CHRONO宏激活.

如果chrono不可用,可使用Boost.Chrono庫. basic_waitable_timer類仍可用.

使用Boost.Asio

支持平台

在如下平台和編譯器下測試通過:

  • Win32 and Win64 using Visual C++ 7.1 and Visual C++ 8.0.
  • Win32 using MinGW.
  • Win32 using Cygwin. (__USE_W32_SOCKETS must be defined.)
  • Linux (2.4 or 2.6 kernels) using g++ 3.3 or later.
  • Solaris using g++ 3.3 or later.
  • Mac OS X 10.4 using g++ 3.3 or later.

也可用於如下平台:

  • AIX 5.3 using XL C/C++ v9.
  • HP-UX 11i v3 using patched aC++ A.06.14.
  • QNX Neutrino 6.3 using g++ 3.3 or later.
  • Solaris using Sun Studio 11 or later.
  • Tru64 v5.1 using Compaq C++ v7.1.
  • Win32 using Borland C++ 5.9.2

依賴

為使程序可連接到Boost.Asio如下庫必須可用:

  • 提供boost::system::error_code 和 boost::system::system_error 的Boost.System庫.
  • 如果使用帶boost::regex參數重載的read_until()或async_read_until()函數,需要Boost.Regex庫.
  • 如果使用了Boost.Asio的SSL支持需要OpenSSL庫.

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

 

 

注意Note

在MSVC或Borland C++中可以在項目設置加入-DBOOST_DATE_TIME_NO_LIB 和 -DBOOST_REGEX_NO_LIB來禁止分別對庫Boost.Date_Time 和 Boost.Regex的自動連接.否則需要生成這些庫並進行連接.

 

生成Boost庫

可以按需要生成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獨立編譯為靜態庫.

如果使用Boost.Asio的SSL支持,需要加入#include <boost/asio/ssl/impl/src.hpp>.

宏

下表中的宏可用來控制Boost.Asio的行為.

 

宏Macro

描述Description

BOOST_ASIO_ENABLE_BUFFER_DEBUGGING

激活Boost.Asio的緩沖區調試支持,可幫助識別出在讀寫中引用的無效緩沖區(例如,向std::string寫數據,但在操作完成前就已經被釋放了).

在Microsoft Visual C++中,如果激活編譯器的迭代調試支持這個宏會自動定義,否則需要定義BOOST_ASIO_DISABLE_BUFFER_DEBUGGING.

在G++中,如果啟動標准庫調試(定義了_GLIBCXX_DEBUG宏)這個宏會自動定義,否則需要定義BOOST_ASIO_DISABLE_BUFFER_DEBUGGING 宏.

BOOST_ASIO_DISABLE_BUFFER_DEBUGGING

顯式的關閉Boost.Asio緩沖區調試支持.

BOOST_ASIO_DISABLE_DEV_POLL

顯式關閉Solaris的/dev/poll支持,強制使用select-based實現.

BOOST_ASIO_DISABLE_EPOLL

顯式關閉Linux的epoll支持,強制使用select-based實現.

BOOST_ASIO_DISABLE_EVENTFD

顯式關閉Linux的eventfd支持,強制使用管道進行中斷阻塞的epoll/select系統調用.

BOOST_ASIO_DISABLE_KQUEUE

Explicitly disables kqueue support on Mac OS X and BSD variants, forcing the use of a select-based implementation.

BOOST_ASIO_DISABLE_IOCP

Explicitly disables I/O completion ports support on Windows, forcing the use of a select-based implementation.

BOOST_ASIO_DISABLE_THREADS

Explicitly disables Boost.Asio's threading support, independent of whether or not Boost as a whole supports threads.

BOOST_ASIO_NO_WIN32_LEAN_AND_MEAN

By default, Boost.Asio will automatically define WIN32_LEAN_AND_MEAN when compiling for Windows, to minimise the number of Windows SDK header files and features that are included. The presence of BOOST_ASIO_NO_WIN32_LEAN_AND_MEAN prevents WIN32_LEAN_AND_MEAN from being defined.

BOOST_ASIO_NO_NOMINMAX

By default, Boost.Asio will automatically define NOMINMAX when compiling for Windows, to suppress the definition of the min() and max() macros. The presence of BOOST_ASIO_NO_NOMINMAX prevents NOMINMAX from being defined.

BOOST_ASIO_NO_DEFAULT_LINKED_LIBS

When compiling for Windows using Microsoft Visual C++ or Borland C++, Boost.Asio will automatically link in the necessary Windows SDK libraries for sockets support (i.e.ws2_32.libandmswsock.lib, orws2.lib when building for Windows CE). The BOOST_ASIO_NO_DEFAULT_LINKED_LIBS macro prevents these libraries from being linked.

BOOST_ASIO_SOCKET_STREAMBUF_MAX_ARITY

Determines the maximum number of arguments that may be passed to the basic_socket_streambuf class template's connect member function. Defaults to 5.

BOOST_ASIO_SOCKET_IOSTREAM_MAX_ARITY

Determines the maximum number of arguments that may be passed to the basic_socket_iostream class template's constructor and connect member function. Defaults to 5.

BOOST_ASIO_ENABLE_CANCELIO

Enables use of the CancelIo function on older versions of Windows. If not enabled, calls to cancel() on a socket object will always fail with asio::error::operation_not_supported when run on Windows XP, Windows Server 2003, and earlier versions of Windows. When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used.

The CancelIo function has two issues that should be considered before enabling its use:

* It will only cancel asynchronous operations that were initiated in the current thread.

* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.

For portable cancellation, consider using one of the following alternatives:

* Disable asio's I/O completion port backend by defining BOOST_ASIO_DISABLE_IOCP.

* Use the socket object's close() function to simultaneously cancel the outstanding operations and close the socket.

BOOST_ASIO_NO_TYPEID

Disables uses of the typeid operator in Boost.Asio. Defined automatically if BOOST_NO_TYPEID is defined.

BOOST_ASIO_HASH_MAP_BUCKETS

Determines the number of buckets in Boost.Asio's internal hash_map objects. The value should be a comma separated list of prime numbers, in ascending order. The hash_map implementation will automatically increase the number of buckets as the number of elements in the map increases.

Some examples:

* Defining BOOST_ASIO_HASH_MAP_BUCKETS to 1021 means that the hash_map objects will always contain 1021 buckets, irrespective of the number of elements in the map.

* Defining BOOST_ASIO_HASH_MAP_BUCKETS to 53,389,1543 means that the hash_map objects will initially contain 53 buckets. The number of buckets will be increased to 389 and then 1543 as elements are added to the map.

 

郵件列表

Boost.Asio 的郵件列表可從SourceForge.net查找.新聞組見Gmane.

Wiki

用戶通常受益於Boost.Asio WIKI上的共享范例,提示和FAQ.,請見http://think-async.com/Asio/.

入門教程

基本技能

入門教程的第一小節介紹使用asio工具的基本概念.在開發復雜的網絡程序前,范例程序闡述使用異步定時器的基本技巧.

Sockets簡介

本節教程展示如何使用asio開發一個簡單的客戶端和服務端程序.程序使用TCP和UDP實現了基本的daytime協議.

前面三個程序使用TCP實現daytime協議.

后面三個程序使用UDP實現daytime協議.

本節最后的程序展示如何在一個程序中使用asio來組合TCP和UDP服務.

定時器1-使用同步定時器

本教程演示如何使用asio的定時器執行阻塞等待.

需要包含必要的頭文件:

簡單的包含"asio.hpp"頭文件即可使用所有的asio類.

#include <iostream>
#include <boost/asio.hpp>

由於本例使用了定時器,需要包含相應的Boost.Date_Time頭文件以便於操作定時器.

#include <boost/date_time/posix_time/posix_time.hpp>

所有使用asio的程序都要創建一個io_service對象.這個類提供IO功能支持.在main函數中首先聲明這個類的對象.

int main()
{
  boost::asio::io_service io;

接着聲明一個boost::asio::deadline_timer類型的對象.這些提供IO功能的核心asio類 (或是定時器功能)構造函數的第一個參數總是io_service類的實例.第二個參數設置過期時間為從現在起5秒鍾以后.

  boost::asio::deadline_timer t(io, boost::posix_time::seconds(5));

這是在定時器上阻塞等待的簡單范例.調用deadline_timer::wait()會在定時器到期(5秒鍾)后才返回.

定時器總是有兩個狀態: "到期" 或 "未到期".如果deadline_timer::wait()函數在一個已過期的時間上執行,會立即返回.

  t.wait();

最后在時間到期后輸出著名的"Hello, world!"消息.

  std::cout << "Hello, world!\n";
  return 0;
}

定時器2--異步使用定時器

本范例修改了time1范例,通過在定時器上異步等待演示了如何使用asio異步回調功能.

#include <iostream>
#include <boost/asio.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>

使用asio的異步功能意味着需要定義一個回調函數,在異步操作完成后執行.本程序中定義了一個叫做print的函數,異步等待完成后調用.

void print(const boost::system::error_code& /*e*/)
{
  std::cout << "Hello, world!\n";
}
 
int main()
{
  boost::asio::io_service io;
 
  boost::asio::deadline_timer t(io, boost::posix_time::seconds(5));

接下來,替換范例1中的阻塞等待.調用deadline_timer::async_wait()函數執行異步等待.在這個函數中傳遞了上面定義的print回調函數.

  t.async_wait(&print);

最后,必須在io_service對象上調用io_service::run()成員函數.

Asio庫保證回調函數在調用了io_service::run()的線程上執行.因此只有調用了io_service::run()函數,異步等待完成的回調函數才能被調用.

Io_service::run()將會一直在運行,因為其還有工作要做.本例中,這個工作是異步等待定時器,因此直到定時器過期而且回調函數執行完畢,才會退出.

在調用io_service::run()前為其指定工作是很重要的.例如,如果上例中忘記調用deadline_timer::async_wait(),io_service無事可做,則io_service::run()調用會立即返回.

  io.run();
  return 0;
}

定時器3-向處理器傳遞參數

本程序從Timer2程序修改而來,將timer改為每秒觸發一次.用來闡述如何向處理函數傳遞其他參數.

#include <iostream>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>

為了讓timer循環的過期,需要在回調函數中修改timer的過期時間,而后開始一個新的異步等待.當然必須讓回調函數可以訪問到timer對象.要實現這個效果需要向print函數傳遞兩個參數:

  • 指向timer對象的指針.
  • Timer觸發計數器,以便於實現觸發6次后結束程序運行.
void print(const boost::system::error_code& /*e*/,
    boost::asio::deadline_timer* t, int* count)
{

如上所述,程序使用計時器來停止運行,如果定時器觸發測試超過6次則退出.然而這里並沒有顯式的讓io_service停止運行.在定時器2范例中我們知道,只有無事可做時io_service::run()才會退出.當計數器等於5時就不在啟動新的異步等待,則io_service完成了工作並停止運行.

  if (*count < 5)
  {
    std::cout << *count << "\n";
    ++(*count);

另外將過期時間從前一個過期時間向后延遲一秒.在原來基礎上定義新的過期時間,可以確保定時器標記的秒數不會由於處理函數執行而延時.

    t->expires_at(t->expires_at() + boost::posix_time::seconds(1));

而后在timer上啟動一個新的異步等待.boost::bind()函數用來將回調函數與參數相關聯.deadline_timer::async_wait()函數希望的回調函數形式為void(const boost::system::error_code&).bind函數將回調函數print連同附加的參數轉換為這種正確的函數簽名.

更多Boost.Bind信息見Boost.Bind documentation.

本例中,boost::bind()的boost::asio::placeholders::error參數是傳遞給成了函數的錯誤對象名稱占位符.如果使用boost::bind()初始化異步操作,必須指定與句柄參數列表相一致的參數.在范例4中回調函數不需要這個參數會省略掉.

    t->async_wait(boost::bind(print,
          boost::asio::placeholders::error, t, count));
  }
}
 
int main()
{
  boost::asio::io_service io;

添加一個新的count變量,以便於在timer觸發6次后結束程序運行.

  int count = 0;
  boost::asio::deadline_timer t(io, boost::posix_time::seconds(1));

如步驟4,在main函數中調用了deadline_timer::async_wait()時會向print函數傳遞附加參數.

  t.async_wait(boost::bind(print,
        boost::asio::placeholders::error, &t, &count));
 
  io.run();

最后,驗證print句柄函數中的count變量,輸出其值.

  std::cout << "Final count is " << count << "\n";
 
  return 0;
}

定時器4 -使用成員函數作為處理器

本例演示如何將類的成員函數作為回調處理函數.程序功能與Timer3完全一樣.

#include <iostream>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>

上一個范例中使用print函數作為回調處理函數,本例中首先定義一個printer類.

class printer
{
public:

類的構造函數中有個io_service的引用,用來初始化timer_成員.關閉程序的計時器也聲明為類的成員.

  printer(boost::asio::io_service& io)
    : timer_(io, boost::posix_time::seconds(1)),
      count_(0)
  {

Boost::bind()函數也可用於處理類的成員函數.由於所有的非靜態類成員函數都有一個隱式的this參數,我們需要將this綁定到函數上.與Timer3范例一樣,使用boost::bind()轉換回調處理函數,將其處理為void(constboost::system::error_code&)形式的簽名.

注意這里boost::asio::placeholders::error占位符被忽略,成員函數print不在接收錯誤對象參數.

    timer_.async_wait(boost::bind(&printer::print, this));
  }

在類的析構函數輸出最終的計數器值.

  ~printer()
  {
    std::cout << "Final count is " << count_ << "\n";
  }

成員函數print與上例的print函數非常類似.由於計數器和timer都做為了類的成員,因此不必在進行參數傳遞了.

  void print()
  {
    if (count_ < 5)
    {
      std::cout << count_ << "\n";
      ++count_;
 
      timer_.expires_at(timer_.expires_at() + boost::posix_time::seconds(1));
      timer_.async_wait(boost::bind(&printer::print, this));
    }
  }
 
private:
  boost::asio::deadline_timer timer_;
  int count_;
};

Main函數與上例也很相似,現在聲明一個printer對象並運行io_service.

int main()
{
  boost::asio::io_service io;
  printer p(io);
  io.run();
 
  return 0;
}

同步TCP daytime客戶端

本例展示如何使用asio實現一個TCP客戶端.

需要包含如下頭文件.

#include <iostream>
#include <boost/array.hpp>
#include <boost/asio.hpp>

程序的目的是要訪問daytime服務器,因此需要用戶指定一個服務器.

using boost::asio::ip::tcp;
 
int main(int argc, char* argv[])
{
  try
  {
    if (argc != 2)
    {
      std::cerr << "Usage: client <host>" << std::endl;
      return 1;
    }

所有使用asio的程序都需要一個io_service對象.

    boost::asio::io_service io_service;

我們需要將程序參數中指定的服務器名稱轉換為TCP端點,因此需要定義一個ip::tcp::resolver對象.

    tcp::resolver resolver(io_service);

分析器使用一個查詢對象並獲取一個端點列表.使用服務器的名稱(參數argv[1])以及服務名稱(本例中是daytime)作為參數來構造查詢對象.

    tcp::resolver::query query(argv[1], "daytime");

返回的端點列表為ip::tcp::resolver::iterator類型的迭代器.

    tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);

現在創建並連接Socket.上述的端點列表可能包括IPv4或IPv6類型的端點,需要嘗試每種可能獲取可用的端點.這樣客戶端就獨立於IP版本號了. boost::asio::connect()自動完成這些功能.

    tcp::socket socket(io_service);
    boost::asio::connect(socket, endpoint_iterator);

連接已經打開.現在就可以從服務端讀取數據了.

使用boost::array 來接收數據. boost::asio::buffer()函數自動管理數組大小以防止緩沖區溢出.除了boost::array ,還可以使用char[]或std::vector.

    for (;;)
    {
      boost::array<char, 128> buf;
      boost::system::error_code error;
 
      size_t len = socket.read_some(boost::asio::buffer(buf), error);

當服務端關閉了連接,ip::tcp::socket::read_some() 函數接收到boost::asio::error::eof 錯誤信息,退出客戶端循環.

      if (error == boost::asio::error::eof)
        break; // Connection closed cleanly by peer.
      else if (error)
        throw boost::system::system_error(error); // Some other error.
 
      std::cout.write(buf.data(), len);
    }

最后處理可能拋出的異常.

  }
  catch (std::exception& e)
  {
    std::cerr << e.what() << std::endl;
  }

TCP daytime同步服務器

本例闡述如何使用asio實現TCP服務端應用程序.

#include <ctime>
#include <iostream>
#include <string>
#include <boost/asio.hpp>
 
using boost::asio::ip::tcp;

定義一個make_daytime_string()函數生成發送給客戶端的字符串.這個函數在所有daytime服務應用程序中重用.

std::string make_daytime_string()
{
  using namespace std; // For time_t, time and ctime;
  time_t now = time(0);
  return ctime(&now);
}
 
int main()
{
  try
  {
    boost::asio::io_service io_service;

ip::tcp::acceptor對象用來偵聽新到的連接.這里初始化為使用IPv4協議來偵聽13端口.

    tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v4(), 13));

這是個可迭代的服務端,即每次只能處理一個連接.對每個客戶端鏈接創建一個Socket,而后等待新到來的連接.

    for (;;)
    {
      tcp::socket socket(io_service);
      acceptor.accept(socket);

客戶端訪問我們服務端.當前的時間將傳遞給客戶端.

      std::string message = make_daytime_string();
 
      boost::system::error_code ignored_error;
      boost::asio::write(socket, boost::asio::buffer(message), ignored_error);
    }
  }

最后處理異常.

  catch (std::exception& e)
  {
    std::cerr << e.what() << std::endl;
  }
 
  return 0;
}

異步TCP daytime服務端

main函數

int main()
{
  try
  {

首先創建一個服務對象接收客戶端的連接. io_service對象提供IO服務,如socket就使用這個IO服務對象.

    boost::asio::io_service io_service;
    tcp_server server(io_service);

運行io_service對象使其執行異步操作.

    io_service.run();
  }
  catch (std::exception& e)
  {
    std::cerr << e.what() << std::endl;
  }
 
  return 0;
}

tcp_server 類

class tcp_server
{
public:

構造函數初始化接收器監聽TCP的13端口.

  tcp_server(boost::asio::io_service& io_service)
    : acceptor_(io_service, tcp::endpoint(tcp::v4(), 13))
  {
    start_accept();
  }
 
private:

函數start_accept()創建一個Socket並初始化為異步接收操作,等待新的連接.

  void start_accept()
  {
    tcp_connection::pointer new_connection =
      tcp_connection::create(acceptor_.get_io_service());
 
    acceptor_.async_accept(new_connection->socket(),
        boost::bind(&tcp_server::handle_accept, this, new_connection,
          boost::asio::placeholders::error));
  }

由start_accept()函數初始化的異步接收操作完成后會調用handle_accept()函數.其響應客戶端的請求並再次調用start_accept()函數初始化下一次接收操作.

  void handle_accept(tcp_connection::pointer new_connection,
      const boost::system::error_code& error)
  {
    if (!error)
    {
      new_connection->start();
    }
 
    start_accept();
  }

Tcp連接類

使用shared_ptr和enable_shared_from_this保證tcp_connetion在有相應操作期間保持激活狀態.

class tcp_connection
  : public boost::enable_shared_from_this<tcp_connection>
{
public:
  typedef boost::shared_ptr<tcp_connection> pointer;
 
  static pointer create(boost::asio::io_service& io_service)
  {
    return pointer(new tcp_connection(io_service));
  }
 
  tcp::socket& socket()
  {
    return socket_;
  }

在函數start()中調用boost::asio::async_write()向客戶端寫數據.注意使用的是boost::asio::async_write()而不是ip::tcp::socket::async_write_some(),這樣可以確保發送全部的數據.

  void start()
  {

發送的數據存儲在類成員message_中,在異步操作完成前必須保證數據的有效性.

    message_ = make_daytime_string();

初始化異步操作后,使用boost::bind()傳遞的參數必須與事件處理函數參數列表相匹配.本例中, boost::asio::placeholders::error 和 boost::asio::placeholders::bytes_transferred參數占位符都被去掉了,因為他們沒有在handle_write()中使用.

    boost::asio::async_write(socket_, boost::asio::buffer(message_),
        boost::bind(&tcp_connection::handle_write, shared_from_this(),
          boost::asio::placeholders::error,
          boost::asio::placeholders::bytes_transferred));

再次處理客戶端連接請求需要由handle_write()負責.

  }
 
private:
  tcp_connection(boost::asio::io_service& io_service)
    : socket_(io_service)
  {
  }
 
  void handle_write(const boost::system::error_code& /*error*/,
      size_t /*bytes_transferred*/)
  {
  }
 
  tcp::socket socket_;
  std::string message_;
};

移除無用的事件處理函數的參數

你可能發現error和bytes_transferred參數在函數handle_write()中是無用的.如果參數不需要可將其移除:

  void handle_write()
  {
  }

boost::asio::async_write()的調用調整為如下形式:

  boost::asio::async_write(socket_, boost::asio::buffer(message_),
      boost::bind(&tcp_connection::handle_write, shared_from_this()));

DDaytime4-同步UDP daytime客戶端

本范例程序展示如何使用asio來實現UPD客戶端程序.

#include/span> <iostream>

#include <boost/array.hpp>

#include <boost/asio.hpp>

 

using boost::asio::ip::udp;;

啟動程序的方式和TCP daytime客戶端相同.

int/span> main(int argc, char* argv[])

{

  try

  {

    if (argc != 2)

    {

      std::cerr << "Usage: client <host>" << std::endl;

      return 1;

    }

 

    boost::asio::io_service io_service;;

向ip::udp::resolver傳遞主機和服務名稱獲取正確的遠程端點.查詢通過ip::udp::v4()參數限制使其返回一個IPv4協議的端點.

    udp::resolver resolver(io_service);

    udp::resolver::query query(udp::v4(), argv[1], "daytime"));

ip::udp::resolver::resolve()函數保證如果查詢成功的話會返回至少有一個端點的列表.因此可以安全的直接對返回值進行解引用.

   udp::endpoint receiver_endpoint = *resolver.resolve(query));

由於UDP是基於數據報的,沒有使用基於流的Socket.創建一個ip::udp::socket並使用遠程端點進行初始連接.

   udp::socket socket(io_service);

   socket.open(udp::v4());

   boost::array<char, 1> send_buf  = {{ 0 }};

   socket.send_to(boost::asio::buffer(send_buf), receiver_endpoint));

現在需要准備好接收服務端發送過來的數據.客戶端接收服務端響應的端點要通過ip::udp::socket::receive_from()指定.

   boost::array<char, 128> recv_buf;

   udp::endpoint sender_endpoint;

   size_t len = socket.receive_from(

       boost::asio::buffer(recv_buf), sender_endpoint);

   std::cout.write(recv_buf.data(), len);

 }}

 

 catch (std/span>::exception& e)

 {

   std::cerr << e.what() << std::endl;

 }

 return 0;

}

Daytime5- daytime同步UDP服務端

本范例程序展示如何使用asio實現同步UDP服務程序.

int main()
{
  try
  {
    boost::asio::io_service io_service;

創建ip::udp::socket對象接收UDP 13端口上的請求.

    udp::socket socket(io_service, udp::endpoint(udp::v4(), 13));

等待客戶端請求連接.remote_endpoint對象將傳入ip::udp::socket::receive_from()函數.

    for (;;)
    {
      boost::array<char, 1> recv_buf;
      udp::endpoint remote_endpoint;
      boost::system::error_code error;
      socket.receive_from(boost::asio::buffer(recv_buf),
          remote_endpoint, 0, error);
 
      if (error && error != boost::asio::error::message_size)
        throw boost::system::system_error(error);

接着實現向客戶端發送數據.

      std::string message = make_daytime_string();

向remote_endpoint發送響應.

      boost::system::error_code ignored_error;
      socket.send_to(boost::asio::buffer(message),
          remote_endpoint, 0, ignored_error);
    }
  }

最后處理異常.

  catch (std::exception& e)
  {
    std::cerr << e.what() << std::endl;
  }
 
  return 0;
}

Daytime6- daytime異步UDP服務端

main()函數

int main()
{
  try
  {

創建服務對象接收客戶端請求,並運行io_service對象.

    boost::asio::io_service io_service;
    udp_server server(io_service);
    io_service.run();
  }
  catch (std::exception& e)
  {
    std::cerr << e.what() << std::endl;
  }
 
  return 0;
}

udp_server類

class udp_server
{
public:

構造函數初始化socket並偵聽UDP的13端口.

  udp_server(boost::asio::io_service& io_service)
    : socket_(io_service, udp::endpoint(udp::v4(), 13))
  {
    start_receive();
  }
 
private:
  void start_receive()
  {

ip::udp::socket::async_receive_from()函數使應用程序在后台偵聽新的請求.當接收到請求,io_service對象使用兩個參數來調用handle_receive函數:一個描述操作成功失敗的boost::system::error_code類型參數,和一個size_t類型的bytes_transferred 指定接收到的字節數.

    socket_.async_receive_from(
        boost::asio::buffer(recv_buffer_), remote_endpoint_,
        boost::bind(&udp_server::handle_receive, this,
          boost::asio::placeholders::error,
          boost::asio::placeholders::bytes_transferred));
  }

handle_receive()函數處理客戶端請求.

  void handle_receive(const boost::system::error_code& error,
      std::size_t /*bytes_transferred*/)
  {

error參數包含異步操作的結果.由於這里只提供了一個字節的recv_buffer_來存放客戶端請求,如果客戶端發送的數據過長則io_service會返回錯誤信息.如果發生錯誤則忽略.

    if (!error || error == boost::asio::error::message_size)
    {

生成發送給客戶端的數據.

      boost::shared_ptr<std::string> message(
          new std::string(make_daytime_string()));

調用ip::udp::socket::async_send_to()函數將數據發送到客戶端.

      socket_.async_send_to(boost::asio::buffer(*message), remote_endpoint_,
          boost::bind(&udp_server::handle_send, this, message,
            boost::asio::placeholders::error,
            boost::asio::placeholders::bytes_transferred));

當初始化異步操作時,如果使用boost::bind(),必須指定與回調函數相匹配的參數列表.本程序中,兩個參數占位符(boost::asio::placeholders::error 和 boost::asio::placeholders::bytes_transferred)應該被移除.

開始偵聽下一個客戶端請求.

      start_receive();

對客戶請求的更多處理由handle_send()負責.

    }
  }

handle_send()函數在服務請求結束后調用.

  void handle_send(boost::shared_ptr<std::string> /*message*/,
      const boost::system::error_code& /*error*/,
      std::size_t /*bytes_transferred*/)
  {
  }
 
  udp::socket socket_;
  udp::endpoint remote_endpoint_;
  boost::array<char, 1> recv_buffer_;
};

Daytime7-TCP/UDP異步服務

本范例程序展示如何將已經寫過的兩個異步服務整合到一個服務程序中.

main()函數

int main()
{
  try
  {
    boost::asio::io_service io_service;

創建一個接收TCP客戶端連接的服務對象.

    tcp_server server1(io_service);

創建一個接收UDP客戶端請求的服務對象.

    udp_server server2(io_service);

已經創建了兩個基於io_service對象上的工作對象.

    io_service.run();
  }
  catch (std::exception& e)
  {
    std::cerr << e.what() << std::endl;
  }
 
  return 0;
}

tcp_connection 和 tcp_server 類

如下兩個類取自Daytime3范例.

class tcp_connection
  : public boost::enable_shared_from_this<tcp_connection>
{
public:
  typedef boost::shared_ptr<tcp_connection> pointer;
 
  static pointer create(boost::asio::io_service& io_service)
  {
    return pointer(new tcp_connection(io_service));
  }
 
  tcp::socket& socket()
  {
    return socket_;
  }
 
  void start()
  {
    message_ = make_daytime_string();
 
    boost::asio::async_write(socket_, boost::asio::buffer(message_),
        boost::bind(&tcp_connection::handle_write, shared_from_this()));
  }
 
private:
  tcp_connection(boost::asio::io_service& io_service)
    : socket_(io_service)
  {
  }
 
  void handle_write()
  {
  }
 
  tcp::socket socket_;
  std::string message_;
};
 
class tcp_server
{
public:
  tcp_server(boost::asio::io_service& io_service)
    : acceptor_(io_service, tcp::endpoint(tcp::v4(), 13))
  {
    start_accept();
  }
 
private:
  void start_accept()
  {
    tcp_connection::pointer new_connection =
      tcp_connection::create(acceptor_.get_io_service());
 
    acceptor_.async_accept(new_connection->socket(),
        boost::bind(&tcp_server::handle_accept, this, new_connection,
          boost::asio::placeholders::error));
  }
 
  void handle_accept(tcp_connection::pointer new_connection,
      const boost::system::error_code& error)
  {
    if (!error)
    {
      new_connection->start();
    }
 
    start_accept();
  }
 
  tcp::acceptor acceptor_;
};

udp_server 類

同樣,下面的類取自上一個范例.

class udp_server
{
public:
  udp_server(boost::asio::io_service& io_service)
    : socket_(io_service, udp::endpoint(udp::v4(), 13))
  {
    start_receive();
  }
 
private:
  void start_receive()
  {
    socket_.async_receive_from(
        boost::asio::buffer(recv_buffer_), remote_endpoint_,
        boost::bind(&udp_server::handle_receive, this,
          boost::asio::placeholders::error));
  }
 
  void handle_receive(const boost::system::error_code& error)
  {
    if (!error || error == boost::asio::error::message_size)
    {
      boost::shared_ptr<std::string> message(
          new std::string(make_daytime_string()));
 
      socket_.async_send_to(boost::asio::buffer(*message), remote_endpoint_,
          boost::bind(&udp_server::handle_send, this, message));
 
      start_receive();
    }
  }
 
  void handle_send(boost::shared_ptr<std::string> /*message*/)
  {
  }
 
  udp::socket socket_;
  udp::endpoint remote_endpoint_;
  boost::array<char, 1> recv_buffer_;
};

范例

分配內存

本范例展示如何為異步操作分配必需的內存.

緩沖區

本范例展示如何為Socket讀寫操作創建有引用計數的緩沖區.

聊天程序

本范例實現了聊天程序的服務端和客戶端.這個程序使用具有6字節的消息頭和可變長消息體的自定義協議.

下面針對POSIX的聊天客戶端演示如何使用posix::stream_descriptor類執行控制台輸入輸出.

Echo

展示如何使用同步和異步操作實現一系列簡單的客戶端和服務端.

fock

針對POSIX 的范例程序演示了如何使用Boost.Asio結合fork()系統調用.第一個范例闡述了如何啟動守護進程:

第二個范例闡述了如何在完成句柄中啟動進程.

HTTP客戶端

范例程序簡單的實現了HTTP1.0客戶端.程序演示了如何使用read_until和async_read_until函數.

HTTP服務

范例闡述了在單線程中使用asio實現HTTP1.0服務.演示了如何執行清除命令結束未完成的異步操作.

HTTP服務2

使用io_service-per-CPU 設計的HTTP服務.

HTTP服務3

使用單個io_service並在線程池上調用io_service::run()的HTTP服務.

HTTP服務4

使用無棧協同技術實現單線程HTTP服務.

ICMP

展示如何在ICMP上使用原生的Socket ping遠程主機.

調用

展示如何自定義處理函數調用.將完成句柄加入到一個優先級隊列而不是直接調用.

iostream

展示如何使用ip::tcp::iostream.

廣播

展示使用廣播向訂閱組傳輸包.

序列化

展示如何在asio中使用Boost.Serialization序列號和反序列化結構體,從而實現在Socket上傳輸數據對象.

服務

展示如何向asio的io_service整合自定義功能(本例中是添加了日志功能),以及在basic_stream_socket<>上使用自定義服務.

SOCKS4協議

范例客戶端程序實現了通過代理通信的SOCKS4協議.

SSL

客戶端和服務端范例程序演示了在異步操作中使用ssl::stream<>模板.

超時設定

下面的一系列范例展示了如何在指定時間之后取消長時間運行的異步操作.

定時器

范例演示了如何定制deadline_time實現不同類型的計時器.

Porthopper

本例演示了混合同步和異步操作,及如何在Boost.Asio中使用Boost.Lambda.

無阻塞

展示如何整合實現IO操作的第三方庫來實現Reactor風格的操作.

UNIX領域的Socket

展示如何使用UNIX領域的Socket.

Windows

展示如何在Boost.Asio中使用Windows特有的TransmitFile函數.


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 boost.asio系列——buffer Boost.asio 超時處理 Boost.Asio使用入門 boost.asio源碼剖析 boost.asio系列——Timer Boost.Asio的使用技巧 Boost.ASIO簡要分析-4 多線程 （原創）談談boost.asio的異步發送 boost.asio源碼剖析(三) ---- 流程分析 C++ 異步編程：Boost.Asio
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM