「Boost.Asio C ++ネットワークプログラミング。」 第1章：Boost.Asioの使用開始

こんにちはHabralyudi！

これは私の最初の投稿なので、厳密に判断しないでください。 John Torjoの本Boost.Asio C ++ Network Programmingの無料翻訳を開始したいのですが、ここにリンクがあります。



内容：

• 第1章：Boost.Asioの使用開始
• 第2章：Boost.Asioの基本
  
  
  • パート1：Boost.Asioの基本
  • パート2：非同期プログラミング
• 第3章：エコーサーバー/クライアント
• 第4章：クライアントとサーバー
• 第5章：同期と非同期
• 第6章：Boost.Asio-その他の機能
• 第7章：Boost.Asio-追加トピック

まず、Boost.Asioの概要、組み立て方法、およびいくつかの例を見てみましょう。 Boost.Asioはネットワークライブラリ以上のものであることがわかります。 Boost.Asio- io_service



中心にある最も重要なクラスについても学びます。

Boost.Asioとは何ですか？

つまり、Boost.Asioは、ほとんどの場合、プログラミングネットワークやその他の低レベルI / Oプログラム用のクロスプラットフォームC ++ライブラリです。

ネットワークの問題を解決するための実装は数多くありますが、Boost.Asioはそれらをすべて上回りました。 2005年にBoostによって採用され、その後、多数のBoostユーザーによってテストされ、次のような多くのプロジェクトで使用されています。

• Remoboを使用すると、独自のIPNを作成できます
• libtorrentは、Bittorrentクライアントを実装するライブラリです
• PokerTHは、LANおよびインターネットをサポートするポーカーゲームです

Boost.Asioは、ネットワークだけでなく、シリアルCOMポート、ファイルなどにも機能する入出力の概念をうまく抽象化します。 さらに、入力または出力プログラミングを同期または非同期にすることができます。

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

前のコードスニペットで見ることができるように、関数はストリームのインスタンスを受け入れます。これは何でもかまいません（ソケットだけでなく、読み取りと書き込みも可能です）。

このライブラリは移植性があり、ほとんどのオペレーティングシステムで実行され、1000を超える同時接続で十分に拡張できます。 ネットワーク部分は、BSD（Berkeley Software Distribution）ソケットのフォロワーでした。 TCP（伝送制御プロトコル）ソケット、UDP（ユーザーデータグラムプロトコル）ソケット、IMCP（インターネット制御メッセージプロトコル）ソケットを操作するためのAPIが提供されます。ライブラリも拡張可能なため、必要に応じて独自のプロトコルに適合できます。 。

物語

Boost.Asioは、2003年の開発開始後、2005年12月にBoost 1.35で採用されました。 原作者はChristopher M. Kohlhoffであり、chris @ kohlhoff.comで連絡できます。

ライブラリは、次のプラットフォームとコンパイラでテストされています。

• Visual C ++ 7.1以降を使用する32ビットおよび64ビットのWindows
• MinGWを使用するWindows
• Cygwinを使用するWindows（ __USE_232_SOCKETS
  
  
  
  定義されていることを確認して__USE_232_SOCKETS
  
  
  
  ）
• g ++ 3.3以降を使用する2.4および2.6カーネルベースのLinux
• g ++ 3.3以降を使用するSolaris
• g ++ 3.3以降を使用するMAC OS X 10.4+

また、AIX 5.3、HP-UX 11i v3、QNX Neutrino 6.3、Solarisなどのプラットフォームで動作し、Sun Studio 11 +、True64 v5.1、Windows、Borland C ++ 5.9.2+（ www詳細については.boost.org ）。

依存関係

Boost.Asioは次のライブラリに依存しています。

• Boost.System：このライブラリは、Boostライブラリ（http://www.boost.org/doc/libs/1_51_0/doc/html/boost_system/index.html）のオペレーティングシステムサポートを提供します。
• Boost.Regex：このライブラリ（オプション）は、 boost::regex
  
  
  
  パラメーターを取るread_until()
  
  
  
  またはasync_read_until()
  
  
  
  を使用する場合に使用されます
• Boost.DateTime：このライブラリ（オプション）は、Boost.Asioタイマーを使用する場合に使用されます
• OpenSSL：このライブラリ（オプション）は、Boost.Asioが提供するSSLサポートを使用することにした場合に使用されます。

Buost.Asioビルド

Boost.Asioは純粋なヘッダーライブラリです。 ただし、コンパイラとプログラムのサイズによっては、Boost.Asioをソースファイルとして作成することを選択できます。 これにより、コンパイル時間を短縮できます。 これは、次の方法で実行できます。

• #include <boost/asio/impl/src.hpp>
  
  
  
  を使用するファイルの1 #include <boost/asio/impl/src.hpp>
  
  
  
  （SSLを使用する場合は#include <boost/asio/ssl/impl/src.hpp>
  
  
  
  ）
• すべてのソースファイルで#define BOOST_ASIO_SEPARATE_COMPILATION
  
  
  
  を使用する

Boost.AsioはBoost.Systemに依存し、必ずしもBoost.Regexに依存するわけではないことに注意してください。したがって、少なくとも次のコードを使用してブーストライブラリを構築する必要があります。

 bjam –with-system –with-regex stage
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

テストもビルドする場合は、次のコードを使用する必要があります。

 bjam –with-system –with-thread –with-date_time –with-regex –withserialization stage
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ライブラリには、本書で提供されている例とともに、チェックアウトできる多くの例が付属しています。

重要なマクロ

設定されている場合はBOOST_ASIO_DISABLE_THREADS



使用します。 Boostがストリームサポート付きでコンパイルされているかどうかに関係なく、Boost.Asioのストリームサポートを無効にします。

同期vs非同期

まず、非同期プログラミングは同期プログラミングとは大きく異なります。 同期プログラミングでは、ソケットSからの読み取り（要求）、ソケットへの書き込み（応答）など、すべての操作を順番に実行します。 各操作がブロックされています。 操作はブロックしているため、ソケットの読み取りまたは書き込み中にメインプログラムを中断しないように、通常、入力/出力ソケットを処理する1つ以上のスレッドを作成します。 したがって、同期サーバー/クライアントは通常マルチスレッドです。

一方、非同期プログラムはイベント駆動型です。 操作を開始しますが、いつ終了するかわかりません。 操作の完了時に操作の結果とともにAPIによって呼び出されるcallback



関数を提供しcallback



。 グラフィカルユーザーインターフェースアプリケーションを作成するためのノキアのクロスプラットフォームライブラリであるQTの豊富な経験を持つプログラマーにとって、これは2番目の性質です。 したがって、非同期プログラミングでは、複数のスレッドを用意する必要はありません。

プロジェクトの初期段階（できれば最初）で、どちらのアプローチを使用するかを決定する必要があります。同期の切り替えと非同期の切り替えは、途中での切り替えが難しく、エラーが発生しやすいためです。 APIが大きく異なるだけでなく、プログラムのセマンティクスが大幅に変更されます（通常、非同期ネットワークは同期ネットワークよりもテストとデバッグが困難です）。 ブロッキング呼び出しと多くのスレッド（通常は同期が簡単）または少数のスレッドとイベント（通常は非同期がより複雑）を使用する前に考えてください。

同期クライアントの簡単な例を次に示します。

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

まず、プログラムにはio_service



インスタンスが必要です。 Boost.Asioはio_service



を使用して、オペレーティングシステムのI / Oサービスと通信します。 通常、 io_service



インスタンスは1つで十分です。 次に、接続するアドレスとポートを作成します。 ソケットを作成します。 ソケットをアドレスとポートに接続します。

 //Here is a simple synchronous server:using boost::asio; typedef boost::shared_ptr<ip::tcp::socket> socket_ptr; io_service service; ip::tcp::endpoint ep( ip::tcp::v4(), 2001)); // listen on 2001 ip::tcp::acceptor acc(service, ep); while ( true) { socket_ptr sock(new ip::tcp::socket(service)); acc.accept(*sock); boost::thread( boost::bind(client_session, sock)); } void client_session(socket_ptr sock) { while ( true) { char data[512]; size_t len = sock->read_some(buffer(data)); if ( len > 0) write(*sock, buffer("ok", 2)); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

繰り返しますが、最初のプログラムには少なくとも1つのio_service



インスタンスが必要です。 次に、リッスンするポートを指定して、アクセプター（レシーバー）を作成します。これは、クライアント接続を受け入れる1つのオブジェクトです。

次のループでは、ダミーソケットを作成し、クライアントが接続するのを待ちます。 接続が確立されたら、この接続を処理するスレッドを作成します。

ストリームのclient_session



関数ではclient_session



クライアントのリクエストをリッスンし、それらを解釈して応答します。

単純な非同期クライアントを作成するには、次のようなことを行います。

 using boost::asio; io_service service; ip::tcp::endpoint ep( ip::address::from_string("127.0.0.1"), 2001); ip::tcp::socket sock(service); sock.async_connect(ep, connect_handler); service.run(); void connect_handler(const boost::system::error_code & ec) { // here we know we connected successfully // if ec indicates success }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

プログラムには、少なくとも1つのio_service



インスタンスが必要です。 ソケットを接続して作成する場所を指定します。 その後、接続が確立されるとすぐに、非同期でアドレスとポートに接続されます（これがハンドラーの完了です）。つまり、 connect_handler



が呼び出されます。

connect_handler



呼び出した後、エラーコード（ ec



）を確認し、成功した場合は、サーバーに非同期で書き込むことができます。

service.run()



非同期操作がある限り、 service.run()



ループが実行されることに注意してください。 前の例では、そのような操作はasync_connect



ソケットのみです。 その後、 service.run()



は終了します。

各非同期操作には、操作の完了時に呼び出される関数であるトレーリングハンドラーがあります。

次のコードは、単純な非同期サーバーです。

 using boost::asio; typedef boost::shared_ptr<ip::tcp::socket> socket_ptr; io_service service; ip::tcp::endpoint ep( ip::tcp::v4(), 2001)); // listen on 2001 ip::tcp::acceptor acc(service, ep); socket_ptr sock(new ip::tcp::socket(service)); start_accept(sock); service.run(); void start_accept(socket_ptr sock) { acc.async_accept(*sock, boost::bind( handle_accept, sock, _1) ); } void handle_accept(socket_ptr sock, const boost::system::error_code & err) { if ( err) return; // at this point, you can read/write to the socket socket_ptr sock(new ip::tcp::socket(service)); start_accept(sock); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

前のコードスニペットでは、まず、 io_service



インスタンスを作成します。 次に、リッスンするポートを指定します。 次に、アクセプター（クライアント接続を受信するためのオブジェクト）を作成し、ダミーソケットを作成してクライアント接続を非同期に待機します。

最後に、非同期のservice.run()



ループを実行します。 クライアントが接続すると、 handle_accept



がhandle_accept



（ async_accept



を呼び出す最後のハンドラー）。 エラーがなければ、このソケットを読み取り/書き込み操作に使用できます。

ソケットを使用した後、新しいソケットを作成し、 start_accept()



再度呼び出します。これにより、「クライアントが接続するのを待つ」同様の非同期操作が追加され、 service.run()



サイクルがビジーのままになります。

エラーコードの例外

Boost.Asioでは、例外とエラーコードの両方を使用できます。 すべての同期関数には、エラーの結果として例外をスローしたり、エラーコードを返したりするオーバーロードがあります。 関数がクラッシュすると、 boost::system::system_error



エラーがスローされます。

 using boost::asio; ip::tcp::endpoint ep; ip::tcp::socket sock(service); sock.connect(ep); // Line 1 boost::system::error_code err; sock.connect(ep, err); // Line 2
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

前のコードでは、 sock.connect(ep)



はエラーの場合に例外をスローし、 sock.connect(ep, err)



はエラーコードを返します。

次のコードスニペットをご覧ください。

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

次のコードスニペットは、前のものと似ています。

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

非同期関数を使用する場合、それらはすべて、コールバック関数でチェックできるエラーコードを返します。 非同期関数は例外をスローすることはなく、これを行う意味はありません。 そして、誰が彼を捕まえるでしょうか？

同期関数では、例外とエラーコードの両方（必要な方）を使用できますが、複数使用できます。 それらを混在させると、問題が発生したり、クラッシュしたりする可能性があります（誤って例外の処理を忘れた場合）。 コードが複雑な場合（ソケットへの読み取り/書き込み機能が呼び出される）、おそらく例外を使用し、 try {} catch



ブロックで読み取りおよび書き込み機能を実行することをお勧めします。

 void client_session(socket_ptr sock) { try { ... } catch ( boost::system::system_error e) { // handle the error } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

エラーコードを使用すると、次のコードフラグメントに示すように、接続がいつ閉じられるかを明確に確認できます。

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Boost.Asioのすべてのエラーコードは、 boost::asio::error



名前空間にあります（障害を見つけるために完全な検索を行いたい場合）。 詳細については、 boost/asio/error.hpp



も参照できます。

Boost.Asioのストリーム

Boost.Asioのストリームに関しては、次のことについて話す必要があります。

• io_service
  
  
  
  ： io_service
  
  
  
  クラスはスレッドセーフです。 複数のスレッドがio_service::run()
  
  
  
  呼び出すことができます。 ほとんどの場合、おそらく単一のスレッドからio_service::run()
  
  
  
  呼び出すため、関数はすべてのブロッキング非同期関数が実行されるまで待機します。 ただし、複数のスレッドからio_service::run()
  
  
  
  呼び出すことができます。 これにより、 io_service::run()
  
  
  
  が呼び出すすべてのスレッドがブロックされます。 すべてのコールバック関数は、 io_service::run()
  
  
  
  を呼び出したスレッドのマイルストーンのコンテキストで呼び出されます。 また、1つのスレッドでのみio_service::run()
  
  
  
  を呼び出した場合、すべてのコールバック関数が特定のスレッドのコンテキストで呼び出されることも意味します。
• socket
  
  
  
  ： socket
  
  
  
  クラスはスレッドセーフではありません。 したがって、あるストリームのソケットからの読み取りや別のストリームへの書き込みなどの状況を回避する必要があります（Boost.Asioはもちろん、これが一般的に推奨されます）。
• utility
  
  
  
  ： utility
  
  
  
  クラスは通常、複数のスレッドで使用する意味がなく、スレッドセーフではありません。 それらのほとんどは短時間使用された後、範囲外になります。

Boost.Asioライブラリ自体は、ユーザーのスレッド以外にも複数のスレッドを使用できますが、これらのスレッドからコードが呼び出されないことが保証されています。 これは、コールバック関数が、 io_service::run()



呼び出されるスレッドでのみ呼び出されることを意味します。

ネットワークだけでなく

Boost.Asioは、ネットワークに加えて他のI / Oオブジェクトを提供します。

Boost.Asioでは、 SIGTERM



（プログラムの終了）、 SIGINT



（シグナルの中断）、SIGSEGV（セグメントの違反）などのSIGTERM



を使用できます。

signal_set



のインスタンスを作成し、非同期的に待機するシグナルを指定します。そのうちの1つが発生すると、非同期ハンドラーが呼び出されます。

 void signal_handler(const boost::system::error_code & err, int signal) { // log this, and terminate application } boost::asio::signal_set sig(service, SIGINT, SIGTERM); sig.async_wait(signal_handler);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

SIGINT



生成されると、 signal_handler



ハンドラーに到達します。

Boost.Asioを使用すると、シリアルポートに簡単に接続できます。 WindowsではCOM7ポート名、POSIXプラットフォームでは/ dev / ttyS0：

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

開いた後、次のコードフラグメントに示すように、ポートデータ転送速度、パリティ、ストップビットなどのパラメーターを設定できます。

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ポートが開いている場合は、ストリームで処理できます。さらに、シリアルポートへの読み取りおよび/または書き込み用の無料の関数を使用することをお勧めします。たとえば、次の例：

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Boost.Asioでは、以下に示すように、Windowsファイルに接続し、 read()



、 asyn_read()



などの無料の関数を再び使用することもできます。

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

次のフラグメントのように、パイプ、標準I / O、さまざまなデバイス（通常のファイルではない）などのPOSIXファイル記述子でも同じことができます。

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

タイマー

一部のI / O操作には、完了する時間の制約がある場合があります。 これは非同期操作にのみ適用できます（同期ロックには時間制限がないため）。 たとえば、パートナーからの次のメッセージは100ミリ秒で届きます。

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

前のコードフラグメントでは、時間の終了前にデータを読み取ると、 read



true



に設定され、パートナーは時間通りに到着しました。 それ以外の場合、 deadline_handler



が呼び出されると、 read



はfalse



に設定されたままになりfalse



。つまり、割り当てられた時間の終わりまで連絡がありません。

Boost.Asioでは同期タイマーを使用できますが、通常は単純なsleep



操作と同等です。 行のboost::this_thread::sleep(500);



次のスニペットでも同じことができます。

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

クラスio_service

Boost.Asioを使用するコードのほとんどがio_serviceのインスタンスを使用することを既に見io_service



。 io_service



は、ライブラリで最も重要なクラスであり、オペレーティングシステムを処理し、すべての非同期操作の終了を待機し、完了すると、そのような各操作のハンドラーを呼び出します。

アプリケーションを同期的に作成する場合、このセクションで説明する内容を心配する必要はありません。

io_service



インスタンスio_service



いくつかの方法io_service



使用できます。 次の例では、3つの非同期操作、2つの接続されたソケット、および待機タイマーがあります。

• 1つのio_service
  
  
  
  インスタンスと1つのハンドラーを持つ1つのスレッド：
  
  
  
  

   io_service service_; // all the socket operations are handled by service_ ip::tcp::socket sock1(service_); // all the socket operations are handled by service_ ip::tcp::socket sock2(service_); sock1.async_connect( ep, connect_handler); sock2.async_connect( ep, connect_handler); deadline_timer t(service_, boost::posix_time::seconds(5)); t.async_wait(timeout_handler); service_.run();
        
        
  
          
          
          
        
  
      
          
          
          
        
        
  
          
          
          
        
  
      
       

  
  
  
• 1つのio_service
  
  
  
  インスタンスと複数のハンドラーを持つ多くのスレッド：
  
  
  
  

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

  
  
  
• io_service
  
  
  
  複数のインスタンスと複数のハンドラーを持つ多くのスレッド：
  
  
  
  

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

  
  
  

まず、同じスレッドに複数のio_service



インスタンスをio_service



ことはできません。 次のコードを記述することは意味がありません。

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

前のセクションのコードは意味がありません。最初のサービスを閉じるときにservice_[1].run()



がservice_[0].run()



を必要とするためです。 そのため、すべての非同期service_[1]



操作は処理を待機する必要がありますが、これはお勧めできません。

前述の3つの例すべてで、3つの非同期操作が完了するのを待ちました。 違いを説明するために、しばらくして操作1が終了し、操作2がその直後に終了すると仮定します。

最初のケースでは、1つのスレッドで3つの操作すべてが完了するのを待っています。 最初の操作が完了したら、そのハンドラーを呼び出します。 操作2が最初の操作の直後に終了した場合でも、最初の操作の完了後、ハンドラーを呼び出すために2秒間待機する必要があります。

2番目のケースでは、2つのスレッドで3つの操作が完了するのを待っています。 最初の操作の完了後、最初のスレッドでハンドラーを呼び出します。操作2が完了するとすぐに、すぐに2番目のスレッドでハンドラーを呼び出します（最初のスレッドがビジー状態で、ハンドラーが最初の操作を完了するのを待っている間、2番目のスレッドは他の操作の完了に自由に応答できます）。

後者の場合、操作1がconnect



k sock1



で操作2 connect



kのsock2



場合、アプリケーションは2番目の場合と同様に動作します。最初のスレッドはのハンドラconnect



を処理しsock1



、2番目のスレッドはのハンドラconnect



を処理しsock2



ます。ただし、from sock1



が操作1で、タイムアウトdeadline_timer t



が操作2の場合、最初のスレッドはconnect



from のハンドラーを処理しsock1



ます。したがって、タイムアウトハンドラーdeadline_timer t



は、ハンドラーの動作が完了するまで待機する必要があります。connect



from sock1



（1秒待機）、最初のスレッドでハンドラーへの接続sock1



とタイムアウトハンドラーの両方が処理されますt



。

前の例から学ぶべきことは次のとおりです。

• 基本的なアプリケーションの状況1。複数のハンドラーを同時に呼び出す必要がある場合、またはそれらを順番に呼び出す必要がある場合は、常に問題が発生します。1つのハンドラーの終了に時間がかかる場合、残りのハンドラーは待機する必要があります。
• 2 . , . , . , -.
• 3 . , 2 . , (). , - (, io_service::run()
  
  
  
  ) select/epoll
  
  
  
  ; , / . , , ( 1000 ). select/epoll
  
  
  
  .

アプリケーションが状況3に移行すると思われる場合は、コードのセクション（を呼び出すコードio_service::run()



）が残りのコードから分離されていることを確認して、簡単に変更できるようにしてください。

最後に、.run()



次の例に示すように、制御する操作がこれ以上ない場合は常に完了することを常に忘れないでください。

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この場合、ソケットが接続を確立するとすぐに呼び出されconnect_handler



てservice.run()



終了します。仕事

をservice.run()



続けたい場合は、彼にもっと仕事を提供しなければなりません。この問題を解決するには2つの方法があります。1つの方法は、connect_handler



別の非同期操作を実行して負荷を増やすことです。

2番目の方法は、次のコードを使用して作業の一部をシミュレートすることです。

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

上記のコードservice_.run()



は、useservice_.stop()



またはを呼び出すまで継続して動作しますdummy_work.reset(0); // destroy dummy_work



。

まとめ

Boost.Asioは、ネットワークプログラミングを非常に簡単にする洗練されたライブラリです。組み立ては簡単です。マクロの使用を避け、非常にうまく機能します。オン/オフオプションを有効にするためにいくつかのマクロが提供されていますが、忘れてはならないことがいくつかあります。

Boost.Asioは、同期プログラミングと非同期プログラミングの両方をサポートしています。これらの2つのアプローチは非常に異なり、切り替えは非常に複雑でエラーが発生しやすいため、できるだけ早く1つを選択する必要があります。

同期アプローチを選択した場合、例外とエラーコードを選択できます。例外からエラーコードへの移行は非常に簡単です。関数呼び出し（エラーコード）にもう1つの引数を追加する必要があります。

Boost.Asioは、プログラミングネットワーク専用ではありません。このライブラリには、シグナル、タイマーなど、より価値のある機能がいくつかあります。

次の章では、ネットワークを提供するBoost.Asioの多くの機能とクラスを掘り下げます。さらに、非同期プログラミングに関するいくつかのトリックを学びます。



さて、今日はこれですべてです。気に入った場合は、翻訳を続けます。すべてのコメントについては、コメントを記入してください。



皆さんに幸運を！