Node.js の TCP 接続処理のコア プロセス

int uv_tcp_listen(uv_tcp_t* tcp, int バックログ, uv_connection_cb cb) {
 // リクエストを処理するための戦略を設定します。以下の分析を参照してください。if (single_accept == -1) {
  const char* val = getenv("UV_TCP_SINGLE_ACCEPT");
  single_accept = (val != NULL && atoi(val) != 0); /* デフォルトではオフです。 */
 }
 (単一受け入れ)の場合
  tcp->フラグ |= UV_HANDLE_TCP_SINGLE_ACCEPT;
 // バインドを実行するかフラグを設定します。err = maybe_new_socket(tcp, AF_INET, flags);
 // リスニングを開始する if (listen(tcp->io_watcher.fd, backlog))
  UV__ERR(errno) を返します。
 // コールバックを設定します tcp->connection_cb = cb;
 tcp->フラグ |= UV_HANDLE_BOUND;
 // epoll が接続を監視するときに実行される io ウォッチャーのコールバックを設定します。tcp->io_watcher.cb = uv__server_io;
 // オブザーバー キューを挿入します。この時点では、epoll に追加されていません。poll io ステージは、処理のためにオブザーバー キューをトラバースします (epoll_ctl)
 uv__io_start(tcp->loop, &tcp->io_watcher, POLLIN);

 0を返します。
}

void uv__server_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
 // ループ処理、uv__stream_fd(stream)はサーバーに対応するfdです
 uv__stream_fd(ストリーム) != -1 の場合{
  // accept を介してクライアントと通信するための fd を取得します。この fd はサーバーの fd と異なることがわかります。err = uv__accept(uv__stream_fd(stream));
  // uv__stream_fd(stream) に対応する fd は非ブロッキングです。このエラーを返すということは、受け入れ可能な接続がないことを意味します。直接 return if (err < 0) {
   エラー == UV_EAGAIN || エラー == UV__ERR(EWOULDBLOCK) の場合
    戻る;
  }
  //記録する stream->accepted_fd = err;
  // コールバックを実行します stream->connection_cb(stream, 0);
  /*
   stream->accepted_fd は -1 です。これは、accepted_fd がコールバック connection_cb で消費されたことを意味します。
   それ以外の場合は、まず epoll でサーバーの fd の読み取りイベントを登録解除し、消費を待ってから再度登録します。つまり、リクエストを処理しなくなります。*/
  ストリーム->accepted_fd != -1 の場合 {
   uv__io_stop(ループ、&stream->io_watcher、POLLIN);
   戻る;
  }
 /*
   わかりました。accepted_fd は消費されましたが、まだ新しい fd を受け入れますか?
   UV_HANDLE_TCP_SINGLE_ACCEPT が設定されている場合、一度に 1 つの接続のみが処理され、その後、他のプロセスが受け入れる機会を与えるためにしばらくスリープ状態になります (マルチプロセス アーキテクチャの場合)。マルチプロセスアーキテクチャでない場合は、これを再度設定します。
   これにより、接続処理が遅延します*/
  if (stream->type == UV_TCP &&
    (ストリーム->フラグ & UV_HANDLE_TCP_SINGLE_ACCEPT)) {
   構造体timespecタイムアウト = {0, 1};
   ナノスリープ(&timeout, NULL);
  }
 }
}

//接続テンプレート <typename WrapType, typename UVType> がある場合にトリガーされるコールバック
void ConnectionWrap<WrapType, UVType>::OnConnection(uv_stream_t* ハンドル,
                          int ステータス) {
 // Libuv 構造体 WrapType* に対応する C++ レイヤー オブジェクトを取得します。 wrap_data = static_cast<WrapType*>(handle->data);
 CHECK_EQ(&wrap_data->handle_, reinterpret_cast<UVType*>(handle));

 環境* env = wrap_data->env();
 ハンドルスコープ handle_scope(env->isolate());
 コンテキスト::スコープ context_scope(env->context());

 //クライアントと通信するためのオブジェクト Local<Value> client_handle;

 （ステータス == 0）の場合{
  // クライアントの JavaScript オブジェクトとハンドルをインスタンス化します。
  // オブジェクトを使用して新しい js レイヤーを作成します Local<Object> client_obj;
  if (!WrapType::Instantiate(env, wrap_data, WrapType::SOCKET)
       .ToLocal(&client_obj))
   戻る;

  // クライアントの JavaScript オブジェクトをアンラップします。
  ラップタイプ* ラップ;
  // js レイヤーで使用されるオブジェクト client_obj に対応する c++ レイヤー オブジェクトを wrap に格納します。ASSIGN_OR_RETURN_UNWRAP(&wrap, client_obj);
  // 対応するハンドルを取得する
  uv_stream_t* クライアント = reinterpret_cast<uv_stream_t*>(&wrap->handle_);
  // handleAccept によって受信された fd の 1 つを取得してクライアントに保存し、クライアントがクライアントと通信できるようにします if (uv_accept(handle, client))
   戻る;
  クライアントハンドル = クライアントオブジェクト;
 } それ以外 {
  client_handle = 未定義(env->isolate());
 }
 // コールバック js、client_handle は js レイヤーで新しい TCP を実行することと同等です
 Local<Value> argv[] = { Integer::New(env->isolate(), status), client_handle };
 wrap_data->MakeCallback(env->onconnection_string(), arraysize(argv), argv);
}

int uv_accept(uv_stream_t* サーバー、uv_stream_t* クライアント) {
 整数エラー;

 スイッチ (クライアント->タイプ) {
  UV_NAMED_PIPEの場合:
  UV_TCPの場合:
   // fdをクライアントに設定 err = uv__stream_open(client,
              サーバー->accepted_fd、
              UV_HANDLE_READABLE または UV_HANDLE_WRITABLE のいずれかです。
   壊す;
 // ...
 }

 クライアント->フラグ |= UV_HANDLE_BOUND;
 // fd が消費されたことをマークする
 サーバー->accepted_fd = -1;
 エラーを返します。
}

constソケット = 新しいソケット({
  ハンドル: clientHandle、
  半開きを許可: self.半開きを許可、
  作成時に一時停止: 接続時に自己一時停止、
  読み取り可能: true、
  書き込み可能: true
 });