1秒ごとに聞きに行くのをやめられます。SSEとWebSocketを両方書いて、使い分けを決めます。
前回: トランザクションとACID — ROLLBACKしたのに戻らない
これは【深掘り】の記事です。本線の順路ではありません。 このシリーズは言葉を覚える回にしません。 全部、手元で書いて、走らせて、数字を出します。 飛ばしても本線は進めます。 本線側の「サーバーから勝手には送れない」話は サーバーから勝手には送れない — WebSocketとSSE にあります。 この記事は、その一段下――WebSocket や SSE が乗っている「ソケット」そのものを掘ります。
この記事のコマンドは、VMの中(Ubuntu Server)で打ちます。 Windows の PowerShell ではありません。VM の立て方は VMを29台溜めた話 — Ubuntu Serverの立て方 にあります。
この記事で立てるサーバーは、全部
127.0.0.1(自分自身)だけで待ち受けます。 外に開きません。他人のサーバーに繋ぐ話は一切しません。 全部、自分のVMの中で完結します。
「新着があったら画面に出したい」だけでした。
作っていたのは、ただの掲示板です。誰かが書き込んだら、他の人の画面にも出てほしい。それだけでした。
私が最初に書いたのはこれです。
setInterval(async () => {
const r = await fetch('/messages');
render(await r.json());
}, 1000);
動きました。 1秒以内に出ます。満足しました。
そのあと、サーバーのアクセスログを見ました。
同時に開いていたのは、自分のブラウザ2枚だけです。それなのに1分で120行ログが増えていました。 そして、そのうち書き込みがあったのは2行だけでした。
残りの118回は、「何もありません」と答えるためだけに飛んだリクエストでした。 人が10人になれば600回。100人なら6000回。中身は全部「無し」です。
「じゃあ WebSocket にすればいいのか」と思って調べました。そこで詰まりました。
記事はどれも new WebSocket(...) から始まります。その WebSocket が何の上に乗っているのかが分かりません。 ws:// は HTTP なのか、違うのか。なぜ「アップグレード」という言葉が出てくるのか。 そして SSE というもう1つの選択肢が、なぜ「ただのHTTP」と言われるのか。
全部、1つ下の層を見ないと分かりませんでした。
HTTP も WebSocket も SSE も、全部「ソケット」という同じ1本の管の上に乗っています。 ソケットは1本の電話線です。 繋がっている間だけ、両方向にバイトが流れる。それだけです。 そして電話線には「ここまでが1つの言葉です」という区切りがありません。
この記事では、その電話線を素で1本引きます。 Node.js の net で、HTTP も何も使わずに。 そして、区切りが無いせいで壊れるところを実際に起こして、直します。
そのあとで初めて、ポーリング・ロングポーリング・SSE・WebSocket を、全部自分で書いて、数字で比べます。
似たタイトルの記事があります。役割が違います。 この記事は選び方と比較を扱います。サーバーから勝手には送れない — WebSocketとSSE は実際に実装して動かす手順を扱います。
対象レベル: 中級〜上級 / 区分: 発展
この記事でわかること
- OSI参照モデルの7層は暗記するものではない。見るのは「自分が書いているコードはどの層か」の1点だけ
- 実際に動いているのは TCP/IP の4層。7層は「話をするための地図」で、実装ではない
- TCP はストリーム。メッセージの区切りが無い。だから 200回
writeしてもdataは17回しか起きない - 区切りは自分で決める。 改行区切りか、長さプレフィックスか。改行区切りは中身に改行が入ると壊れる
- UDP は「届く保証も順番の保証も無い」代わりに、メッセージの区切りは保つ。TCP と逆
- ショートポーリングは、60秒で59回投げて53回が空振り(89.8%が無駄)
- ロングポーリングは同じ60秒で7回に減る。代償はサーバーが接続を持ち続けること
- SSE は「ただの
text/event-streamな HTTP レスポンス」。curlで全部読める。再接続はブラウザが勝手にやる - WebSocket は HTTP でハンドシェイクしてから、プロトコルを乗り換える。
101 Switching Protocolsがその瞬間 - 結論は3行で言える。 通知だけなら SSE。双方向が要るときだけ WebSocket。1分に1回でよいならポーリングで十分
この記事でやること
curlを1回打って、その1回で何層が動いたかを上から下まで表にする- Node.js の
netで 素のTCPサーバーとクライアントを書き、ssとncで外から確かめる - 200回
writeしてdataが17回しか起きないところを再現し、改行区切りと長さプレフィックスの両方で直す dgramで UDP版を書き、わざとパケットを落としてTCPとの違いを数字で見る- ショートポーリングを実装して、60秒間の空振り率を実測する
- ロングポーリングを実装して、リクエスト数がどれだけ減るかと、代わりに何が増えるかを測る
- SSE の生バイト列を
curl -Nで見て、WebSocket の101をcurl -iで取り、フレームを1つ手で解読する - 4つを判断表にして、どれをいつ使うか決める
先に知る言葉
この記事で初めて出てくる言葉です。 基本的な言葉は用語集にもまとめてあります。
| 言葉 | 意味 |
|---|---|
| ソケット | 通信の口。「IPアドレス + ポート番号」の組で1つの端。繋がると1本の管になる |
| TCP | 届いたことを確認しながら送る方式。順番も保証する。代わりに遅い |
| UDP | 投げっぱなしの方式。届いたか確認しない。代わりに軽い |
| ストリーム | 切れ目のないバイトの流れ。TCP はこれ。「1件」「2件」という単位が無い |
| データグラム | 1個で完結する小包。UDP はこれ。区切りは保たれるが、届く保証は無い |
| フレーミング | ストリームの中に「ここまでが1件」の印を自分で入れること |
| ポーリング | こちらから定期的に「変わりましたか」と聞きに行くこと |
| ロングポーリング | 聞きに行って、変化があるまでサーバーが返事を保留するやり方 |
| SSE | Server-Sent Events。サーバー→ブラウザの一方通行。中身はただのHTTPレスポンス |
| WebSocket | HTTPで挨拶してから乗り換える、双方向の通信路 |
① 通信は7層に分かれている(が、実際は4層)
最初に断っておきます。OSI参照モデルの7層は、暗記しても何も解決しません。
私も一度、7つの層の名前を語呂合わせで覚えました。現場で1回も使いませんでした。 使ったのは、「いま自分が困っているのはどの層か」を切り分けるときだけです。
7層と4層の対応
OSI の7層は「話をするための地図」で、実装ではありません。 実際に動いているのは TCP/IP の4層です。この2つを1枚の表にします。
| OSI(7層・地図) | TCP/IP(4層・実物) | ここで動くもの | 自分が書くコードとの関係 |
|---|---|---|---|
| 第7層 アプリケーション | アプリケーション層 | HTTP, DNS, SSH, WebSocket, SSE | 普段書いているコードはほぼ全部ここ |
| 第6層 プレゼンテーション | 同上(分かれていない) | TLS, 文字コード, 圧縮 | HTTPS の「S」の部分 |
| 第5層 セッション | 同上(分かれていない) | 接続の張り直し, Cookie | TCP/IP では独立した層が無い |
| 第4層 トランスポート | トランスポート層 | TCP, UDP | この記事の②〜④はここを直接触る |
| 第3層 ネットワーク | インターネット層 | IP, ルーティング, ICMP | ping が届かないときはここ |
| 第2層 データリンク | リンク層 | Ethernet, MACアドレス, ARP | 同じLAN内の話 |
| 第1層 物理 | 同上(分かれていない) | ケーブル, 電波, 光 | LANケーブルが抜けているのもここ |
覚えるのはこの1行だけで足ります。
第4層(TCP/UDP)が「どこへ運ぶか」を決め、第7層(HTTP など)が「何を言うか」を決める。 その境目にあるのがソケット。 この記事はずっとその境目にいます。
本線側では、この層の違いがロードバランサーの選び方に直結する話をしています。 L4とL7の違いは中身を見るか — OSI参照モデル を先に読んでも構いません。
curl 1回で、どの層が何をしたか
言葉だけだと分かりません。実際に1回打って、層ごとに時間を出します。
作業フォルダを作ります。
/home/user/cslab/rt
curl には「どの段階まで何秒かかったか」を出す機能があります。
dns: 0.007089
tcp: 0.030142
tls: 0.066186
request: 0.066418
firstbyte:0.191164
total: 0.211749
ip: 183.181.97.30
port: 443
http: 1.1
code: 200
この数字は「累計」です。 差を取ると、どの層に何秒かかったかが出ます。
| 順番 | 何が起きたか | 層 | かかった時間 | 失敗するとどう見えるか |
|---|---|---|---|---|
| 1 | obmes.com → 183.181.97.30 に変換 | 第7層(DNS) | 7.1ms | Could not resolve host |
| 2 | 相手の 443番ポートまでの経路を通る | 第3層(IP) | (2に含まれる) | 応答が返らずタイムアウト |
| 3 | TCPの3ウェイハンドシェイク | 第4層(TCP) | 30.1 − 7.1 = 23.0ms | Connection refused |
| 4 | TLSハンドシェイク(証明書の確認と鍵の合意) | 第6層(TLS) | 66.2 − 30.1 = 36.0ms | certificate verify failed |
| 5 | GET / HTTP/1.1 を送って最初の1バイトが返る | 第7層(HTTP) | 191.2 − 66.4 = 124.7ms | 404 / 500 |
| 6 | 本文を全部受け取る | 第7層 | 211.7 − 191.2 = 20.6ms | 途中で切れる |
ここが一番大事な読み方です。
「サイトが重い」と言われたとき、見るのはこの6行のどこが太っているかです。 – DNS が遅い → DNSサーバーの問題。アプリのコードを直しても直らない – TCP が遅い → 距離か経路の問題。サーバーを近くに置く以外に手が無い – TLS が遅い → 証明書チェーンか、接続を毎回張り直している – firstbyte が遅い → ここで初めてアプリのコードの話になる
私は昔、DNSが遅かっただけの案件で、丸2日アプリのSQLを見ていました。 層で切ってから中に入る。 この順番を守らないと、いくらでも時間が溶けます。
ドメインとHTTPSそのものの話は DNSとHTTPSを自分のドメインで確かめる — 未経験の1歩目 にあります。
📸 スクリーンショット1: 上の
curl -wの出力。dnstcptlsfirstbyteの4つの数字が並んでいるところを残す
② ソケットを素で書く — HTTPもWebSocketも全部この上に乗っている
ここから、第4層を直接触ります。HTTP は使いません。
Node.js の net モジュールは、TCPのソケットをそのまま扱えます。
これで全部です。 HTTP のヘッダも、ルーティングも、ステータスコードもありません。 「繋がったらバイトが流れてくる。そのまま返す」だけです。
'127.0.0.1' を必ず書いてください。 省略すると全部のネットワークで待ち受けます。 学習用のVMを外に開く理由はありません。
動かします。別のターミナルをもう1枚開いてください(VS Code から繋いでいるなら、下のターミナルを + で増やせます)。
listen 127.0.0.1:9001
本当に待ち受けているか、外から確かめる
「動いているつもり」が一番危ないので、必ず別の道具で確認します。
もう1枚のターミナルで打ちます。
State Recv-Q Send-Q Local Address:Port Peer Address:Port Process
LISTEN 0 511 127.0.0.1:9001 0.0.0.0:* users:(("node",pid=3184,fd=21))
オプションの意味です。
| オプション | 意味 |
|---|---|
-t | TCP だけ表示する |
-l | 待ち受けている(LISTEN)ものだけ |
-n | 番号のまま出す(http ではなく 80) |
-p | どのプロセスかを出す(sudo が要ることがある) |
Local Address が 127.0.0.1:9001 になっていることを確認してください。 ここが 0.0.0.0:9001 だったら、VMの外からも届く状態です。すぐ止めてください。
ネットワークの切り分けそのものは 「繋がらない」を4段階で切り分ける — Linuxのネットワーク にまとめてあります。
nc で手打ちして繋ぐ
ソケットは「1本の電話線」です。手で喋れます。
nc(netcat)は、キーボードで打った文字をそのままソケットに流す道具です。
/usr/bin/nc
繋ぎます。
何も出ません。プロンプトも返りません。 これが正常です。 電話が繋がって、無言でいる状態です。
hello と打って Enter を押します。
hello
hello
2行目は自分が打ったものではありません。 サーバーが返してきたものです。 Ctrl+C で切ります。
サーバー側のターミナルを見ます。
listen 127.0.0.1:9001
[接続] 127.0.0.1:63702
[受信] 6 バイト: "hello\n"
[切断] 127.0.0.1:63702
6 バイト です。 hello は5文字なので、Enter で入った改行が1バイト混ざっています。 nc は改行も込みで送ります。この「1バイト」が、③で全部の原因になります。
コードから繋ぐ
nc と同じことをコードで書きます。
つながった
返ってきた: "hello\n"
閉じた
サーバー側です。
[接続] 127.0.0.1:63702
[受信] 6 バイト: "hello\n"
[切断] 127.0.0.1:63702
nc で打ったときと、1バイトも変わりません。
これが一番言いたいことです。 HTTP も WebSocket も SSE も、この
sock.write()の上に乗っている「決めごと」でしかありません。 HTTP は「最初にGET / HTTP/1.1\r\nと書く」という決めごと。 WebSocket は「HTTPで挨拶してから、独自の形のバイト列を流す」という決めごと。 管そのものは、いま書いたこれと同じです。
「サーバーとは待ち続けるプログラムである」という話は サーバーとは待ち続けるプログラム — 手で書いて確かめる にあります。
サーバーは Ctrl+C で止めておきます。
③ TCPはストリーム。メッセージの区切りが無い
ここが、この記事で一番大事なところです。
私は長いこと、こう思っていました。
❌ 「
writeを1回呼んだら、相手側でdataが1回起きる」
違います。 そして、ローカルで少ないデータを試している間は、たまたま合ってしまいます。 本番で件数が増えた瞬間に壊れます。 私はそれで、チャットの投稿がJSONのパースエラーで消えるバグを出しました。
実際に壊す
200回 write します。 受け取る側は「1回の data = 1件」だと思い込んで数えます。
サーバーを起こしてから、クライアントを走らせます。
listen 127.0.0.1:9002
write を 200 回呼んだ
data #1: 342バイト "{\"n\":1}\n{\"n\":2}\n{\"n\":3}\n{\"n\":4}\n{\"n\":5}\n{\"n\":6}\n{\"n\":7}\n{\"n\""…
data #2: 396バイト "{\"n\":40}\n{\"n\":41}\n{\"n\":42}\n{\"n\":43}\n{\"n\":44}\n{\"n\":45}\n{\"n\":4"…
data #3: 174バイト "{\"n\":84}\n{\"n\":85}\n{\"n\":86}\n{\"n\":87}\n{\"n\":88}\n{\"n\":89}\n{\"n\":9"…
---
data イベントの回数: 17
受け取ったと思った件数: 17
200回
writeしたのに、dataは 17回しか起きていません。 1回目のdataには、39件分がまとめて入っています。
もしここで JSON.parse(buf.toString()) と書いていたら、こうなります。
SyntaxError: Unexpected non-whitespace character after JSON at position 8
私が本番で見たのは、まさにこのエラーでした。 そして開発中は1回も出ませんでした。 手で1件ずつ投稿している間は、たまたま1対1で届いていたからです。
なぜまとまるのか
TCP は「バイトの流れ」しか運びません。 送った側の write の切れ目という情報は、そもそも運ばれません。
| 何が起きているか | 説明 |
|---|---|
| 送信側でまとまる | OSが送信バッファに溜めて、まとめて1つのパケットで送る(ネーグルアルゴリズム) |
| 受信側でまとまる | 届いたパケットが受信バッファに溜まり、アプリが読みに行ったときに全部渡される |
| 逆に、割れることもある | 1回の write が大きいと、複数の data に分かれて届く(MTUを超えるため) |
「まとまる」と「割れる」の両方が起きます。 つまり――
writeの回数とdataの回数には、何の関係もありません。dataの切れ目に意味を求めた瞬間、そのコードは壊れます。
直し方その1: 改行区切り
区切りは自分で決めるしかありません。 一番簡単なのは「改行までが1件」と決めることです。
やることは1つ。「余った分をためておく箱」を持つことです。
listen 127.0.0.1:9003
write を 200 回呼んだ
メッセージ 1: n=1
メッセージ 2: n=2
---
data イベントの回数: 5
組み立てたメッセージ数: 200
箱に残ったバイト数: 0
dataは5回しか起きていないのに、200件ちょうど組み立てられました。箱に残ったバイト数: 0が「途中で切れたものが無い」証拠です。
ここが確認のポイントです。 最後に箱が空でなければ、半端なデータが残っている=プロトコルが合っていません。
改行区切りが壊れる場面
改行区切りには、はっきりした弱点があります。
中身に改行が入っていたら、そこで割れます。
実際に起こします。
メッセージ 1: "こんにちは"
メッセージ 2: "1行目"
メッセージ 3: "2行目"
合計 3 件
2件送ったのに3件になりました。 チャットで Shift+Enter の改行を許した瞬間、投稿が2つに割れます。
対処は2つあります。
- 中身をエスケープする(
JSON.stringifyすれば\nは\\nになるので割れない) - そもそも改行に頼るのをやめる
2番目をやります。
直し方その2: 長さプレフィックス
「最初に本体の長さを書く」やり方です。中身に何が入っていても壊れません。
[4バイト: 本体の長さ][本体]
listen 127.0.0.1:9004
---
data イベントの回数: 4
組み立てたメッセージ数: 200
箱に残ったバイト数: 0
dataが4回しか起きていないのに、200件ちょうど。 しかも、中に改行が入ったメッセージも、30000文字の巨大なメッセージも、全部正しく1件です。
grep を外して1件目だけ見ると、こうなっています。
メッセージ 1: "1行目\n2行目"
改行が中に入ったまま、1件として届いています。
2つのやり方の比較
| 改行区切り | 長さプレフィックス | |
|---|---|---|
| 実装 | 簡単(indexOf('\n') だけ) | やや面倒(Buffer を扱う) |
| 中身に区切り文字 | 壊れる(エスケープが要る) | 壊れない |
| 人が読めるか | nc で目視できる | 読めない(バイナリ) |
| 事前に長さが要るか | 要らない | 本体を作りきってからでないと書けない |
| 実物の例 | HTTP のヘッダ部, SMTP, Redis の一部 | WebSocket のフレーム, gRPC, MySQL の通信 |
WebSocket が長さプレフィックス方式なのは偶然ではありません。 中身が何であっても壊れないからです。⑦でそのフレームを実際に解読します。
📸 スクリーンショット2:
naive-server.mjsのdata イベントの回数: 17と、line-server.mjsの組み立てたメッセージ数: 200を並べて残す
④ UDP と比べる — 届く保証は無いが、区切りは保たれる
TCP の反対側を見ます。
UDP は「投げっぱなし」です。 届いたかも確認しないし、順番も直しません。 その代わり、TCP と正反対の性質を1つ持っています。
まず普通に投げる
send を 5000 回呼んだ
UDP listen 127.0.0.1:9010
受信 1: 1バイト "1" from 127.0.0.1:58918
受信 2: 1バイト "2" from 127.0.0.1:58918
受信 3: 1バイト "3" from 127.0.0.1:58918
---
受け取った件数: 5000 / 送られた件数: 5000
順番どおりだったか: はい
最初の10件: 1,2,3,4,5,6,7,8,9,10
5000 回 sendして、messageイベントが 5000 回起きています。 ③の TCP では 200回のwriteが 17回でした。UDP は 1対1 です。
これが UDP の性質です。
UDP には区切りがあります。 1回の
sendが、そのまま1回のmessageになります。 フレーミングのコードを書かなくていい。 ③でやった苦労が、UDP では要りません。
落ちるところを見る
「届いた」のは、127.0.0.1(自分自身)だったからです。 ケーブルもルーターも通っていません。「落ちようがない」経路でした。
それでも落とせます。受信バッファを小さくします。
send を 20000 回呼んだ(1件 1006バイト)
UDP listen 127.0.0.1:9011 / recvBufferSize=2048
---
送られた件数: 20000
受け取った件数: 18145
失われた件数: 1855(9.3%)
順番が逆転した回数: 0
自分から自分へ送っただけで、9.3% が消えました。 エラーは1つも出ていません。 送った側は「送れた」と思っています。
これが UDP の一番怖いところです。
UDP は「落ちた」ことを誰も教えてくれません。 アプリが自分で番号を振って、抜けを検出するしかありません。
同じことを TCP でやると、落ちません。 代わりに write が遅くなります(バッファが埋まると押し戻される)。 TCP は「落とさない代わりに待たせる」。UDP は「待たせない代わりに落とす」。 これが本質です。
対比表
| TCP | UDP | |
|---|---|---|
| 届く保証 | ある(届かなければ再送する) | 無い(消えても誰も気づかない) |
| 順番の保証 | ある(並べ直してから渡す) | 無い(後から出したものが先に着く) |
| メッセージの区切り | 無い(ストリーム。自分で決める) | ある(1 send = 1 message) |
| 接続 | 要る(3ウェイハンドシェイク) | 要らない(いきなり送る) |
| 1件の上限 | 無制限(流れ続ける) | 実用上 1400バイト程度まで |
| 遅れたとき | 待って揃える(そのぶん遅延が伸びる) | 古いものは捨てて先へ進む |
| Node.js のモジュール | net | dgram |
それぞれ何に使われているか
| 用途 | どちら | なぜそちらなのか |
|---|---|---|
| HTTP / HTTPS | TCP | 1バイトでも欠けたらHTMLが壊れる |
| SSH / FTP / SMTP | TCP | 同上。コマンドが化けたら事故 |
| データベース接続 | TCP | 言うまでもない |
| DNS | UDP(大きいときだけTCP) | 1往復で終わる。失敗したらもう1回聞けばいい |
| 動画・音声通話 | UDP | 0.5秒前の映像が今届いても意味が無い。捨てて先へ行くのが正解 |
| オンラインゲーム | UDP | 同上。古い座標より、新しい座標 |
| QUIC(HTTP/3) | UDPの上に自前で再送を実装 | TCPの「1つ詰まると全部止まる」を避けるため |
| NTP(時刻合わせ) | UDP | 軽さが正義 |
「UDPは信頼できないから使わない」は間違いです。 遅れて届くくらいなら捨てたい用途では、UDPのほうが正しいのです。
⑤ ショートポーリングを実装して測る
ここからが冒頭の話です。 1秒ごとに聞きに行くコードを、実際に書いて測ります。
まずサーバーを作ります。10秒に1回だけ新しいメッセージが生まれる世界にします。 実際の掲示板もチャットも、たいていこうです。 大半の時間、何も起きていません。
since を渡しているのが大事です。 「前に受け取った最後のID」を毎回送って、 その先だけ返してもらいます。これが無いと、毎回全件返ることになります。
クライアント側です。
60秒待ちます。
+9.1秒 新着 1 件
+19.2秒 新着 1 件
+29.3秒 新着 1 件
+39.4秒 新着 1 件
+49.4秒 新着 1 件
+59.5秒 新着 1 件
---
経過: 60 秒
飛ばしたリクエスト: 59 回
空振り: 53 回
受け取った新着: 6 件
無駄だった割合: 89.8%
59回投げて、53回が空振りでした。無駄が 89.8%。
この数字を人数で伸ばす
1人でこれです。 掛け算するとこうなります。
| 同時に見ている人数 | 1分あたりのリクエスト | 1時間あたり | そのうち中身があるもの |
|---|---|---|---|
| 1人 | 59回 | 3,540回 | 6回(10.2%) |
| 10人 | 590回 | 35,400回 | 60回 |
| 100人 | 5,900回 | 354,000回 | 600回 |
| 1,000人 | 59,000回 | 3,540,000回 | 6,000回 |
1000人が画面を開いているだけで、1時間に354万リクエストです。 そして、そのうち約90%は「何もありません」を返すためだけに動いています。
さらに悪いこと: 遅延も減っていない
「1秒ごとに聞けば1秒以内に出る」と思うかもしれません。違います。
上の出力を見てください。メッセージが生まれるのは 9秒・19秒・29秒… のタイミングです。 受け取ったのは 9.1秒・19.2秒・29.3秒。平均で 0.5秒遅れています。
ポーリング間隔を
N秒にすると、平均遅延はN/2秒になります。 遅延を半分にしたければ、リクエスト数は2倍。 交換条件から逃げられません。
| 間隔 | 1人1時間のリクエスト | 平均遅延 |
|---|---|---|
| 10秒 | 360回 | 5.0秒 |
| 5秒 | 720回 | 2.5秒 |
| 1秒 | 3,600回 | 0.5秒 |
| 0.5秒 | 7,200回 | 0.25秒 |
この表を見ると、「そもそも間隔を短くする方向が間違っている」と分かります。 次にやることは、間隔を縮めることではありません。
⑥ ロングポーリング — サーバーが返事を保留する
発想を1つ変えます。
「無かったら空を返す」のをやめて、「あるまで返さない」ことにします。
コードでいうと、/wait の中のこの部分です(⑤のサーバーに実装済みです)。
if (fresh.length > 0) return send(fresh); // すでに新着があるなら即返す
const w = { send, timer: null };
w.timer = setTimeout(() => { ... send([]); }, 25000); // 25秒で一度打ち切る
waiters.push(w); // ⚠️ res を持ったまま返事をしない
res をその場で end() せず、配列に入れておくだけです。 新しいメッセージが生まれたときに、溜まっていた res を全部まとめて end() します。
クライアント側は「返ってきたら、すぐ次を投げる」だけの無限ループです。
3人同時に繋いだ状態で測ります。 途中で /stats を叩いて、サーバー側で何が起きているかも見ます。
listen 127.0.0.1:9020
[生成] メッセージ 1 待たせていた人: 3
+9.2秒 新着 1 件
[生成] メッセージ 2 待たせていた人: 3
+19.2秒 新着 1 件
[生成] メッセージ 3 待たせていた人: 3
+29.2秒 新着 1 件
35秒時点の /stats: {"reqCount":13,"emptyCount":0,"messages":3,"waiting":3}
[生成] メッセージ 4 待たせていた人: 3
+39.2秒 新着 1 件
[生成] メッセージ 5 待たせていた人: 3
+49.2秒 新着 1 件
[生成] メッセージ 6 待たせていた人: 3
+59.3秒 新着 1 件
---
経過: 60 秒
飛ばしたリクエスト: 7 回
空振り: 0 回
受け取った新着: 6 件
無駄だった割合: 0.0%
最終 /stats: {"reqCount":23,"emptyCount":0,"messages":6,"waiting":0}
何が変わったか
| ショートポーリング | ロングポーリング | |
|---|---|---|
| 60秒のリクエスト数(1人) | 59回 | 7回 |
| 空振り | 53回 | 0回 |
| 無駄だった割合 | 89.8% | 0.0% |
| 受信のタイミング | 9.1 / 19.2 / 29.3秒 | 9.2 / 19.2 / 29.2秒 |
リクエストが8分の1以下になりました。しかも遅延は変わっていません。
7回の内訳です。 6件のメッセージを受け取るのに6回、最後の1回は返事待ちのまま60秒が来て終了しました。
代償はサーバー側にある
35秒時点の /stats を見てください。
{"reqCount":13,"emptyCount":0,"messages":3,"waiting":3}
waiting: 3。3人ぶんの res を、サーバーが握ったままです。
外からも数えられます。 サーバーが動いている間に、別のターミナルで打ちます。
3
3本の TCP 接続が、何もしていないのに開いたままです。
これがロングポーリングの正体です。
リクエストの「回数」は減りましたが、接続の「本数」は減っていません。 同時接続者の数だけ、サーバーが接続を持ち続けます。
そして、ここが罠です。
| 環境 | 何が起きるか |
|---|---|
| Node.js / Go | 平気。1接続がイベントループの1エントリなので、数万本まで持てる |
| PHP-FPM / Apache prefork | 死ぬ。1接続 = 1プロセス。同時50人でワーカーが枯渇する |
| Rails / Django(同期) | 死ぬ。同上。専用のワーカーを分けるしかない |
| nginx を前に置いている | proxy_read_timeout の既定は 60秒。それを超えると 504 |
| クラウドのロードバランサ | アイドルタイムアウトが 60秒前後。同上 |
サーバー側のコードに setTimeout(..., 25000) を入れているのはこのためです。 プロキシに切られる前に、自分から一度返します。 25秒なら、たいていの既定値の内側に収まります。
nginx を挟むときの話は ポート番号を隠す — nginxのリバースプロキシ にあります。
⑦ SSE と WebSocket — 中身を生で見る
ロングポーリングまで来ると、次の疑問はこれです。
「毎回繋ぎ直さずに、開けっぱなしにして流し込めばいいのでは?」
それが SSE です。 そして SSE は、驚くほど「ただのHTTP」です。
SSE を書く
ライブラリを1つも使っていません。 res.write() を呼び続けているだけです。
curl で生のバイト列を見る
ここが「SSEはただのHTTP」の証明です。
-N が重要です。 これが無いと curl がバッファリングして、最後にまとめて出ます。 リアルタイムに流れてくる様子が見えません。
HTTP/1.1 200 OK
content-type: text/event-stream
cache-control: no-cache
connection: keep-alive
Date: Fri, 04 Sep 2026 01:28:25 GMT
Transfer-Encoding: chunked
retry: 3000
id: 1
event: message
data: {"n":1,"at":"2026-09-04T01:28:26.213Z"}
id: 2
event: message
data: {"n":2,"at":"2026-09-04T01:28:27.228Z"}
id: 3
event: message
data: {"n":3,"at":"2026-09-04T01:28:28.237Z"}
1秒ごとに1ブロックずつ、目の前に出てきます。
これで全部です。バイナリは1バイトもありません。
curlで読める。grepできる。teeでファイルに残せる。 これが SSE の一番の長所です。
SSE の書式
| 行 | 意味 |
|---|---|
data: ... | 本文。これだけが必須 |
id: ... | イベントの番号。再接続のときに使われる |
event: ... | イベント名。ブラウザ側で addEventListener('その名前') で受けられる |
retry: 3000 | 切れたら何ミリ秒後に繋ぎ直すかの指示 |
| 空行 | ここまでが1イベント、という区切り |
③でやった「フレーミング」が、ここにも出てきています。 SSE の区切りは「空行」です。 改行区切りの親戚で、data: の中に改行は書けません(複数行なら data: を並べます)。
Transfer-Encoding: chunked にも注目してください。 Content-Length を書けないからです。いつ終わるか分からないレスポンスなので、長さを先に言えません。
再接続がブラウザ側に入っている
SSE で一番おいしいのはここです。
ブラウザ側のコードはこれだけです。
const es = new EventSource('/events');
es.addEventListener('message', (e) => {
console.log(JSON.parse(e.data));
});
再接続のコードが1行もありません。
サーバーが落ちても、Wi-Fi が切れても、ブラウザが
retry:で指定した秒数後に自動で繋ぎ直します。 しかもLast-Event-IDというヘッダで「最後に受け取ったID」を送ってくれます。 サーバーはその続きから流せば、取りこぼしがゼロになります。
ロングポーリングで自分で書いていた while (running) のループが、ブラウザに最初から入っているということです。 これは自分で書くと必ずバグります(指数バックオフ、タブが非表示のとき、スリープ復帰後…)。
WebSocket — HTTP で挨拶してから乗り換える
SSE はサーバー → ブラウザの一方通行です。 逆方向は普通の fetch で送ります。 それで困る場面――ゲーム、共同編集、音声のやり取り――で初めて WebSocket が要ります。
WebSocket は「HTTPとは別のプロトコル」ですが、始まり方はHTTPです。
ws パッケージも入れていません。 http と crypto だけです。
まず普通の GET を投げてみる
HTTP/1.1 426 Upgrade Required
content-type: text/plain
Date: Fri, 04 Sep 2026 01:28:48 GMT
Connection: keep-alive
Keep-Alive: timeout=5
Transfer-Encoding: chunked
Upgrade Required
426 は「このリソースは、乗り換えないと使えません」という意味のステータスコードです。
curl でハンドシェイクを手で投げる
WebSocket のハンドシェイクは、ただのHTTPリクエストです。curlで書けます。
-m 3 を必ず付けてください。 付けないと 101 が返ったあと curl が永久に待ちます (プロトコルが乗り換わったので、curl はもう終わり方を知りません)。
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
これが「プロトコルが乗り換わった瞬間」です。
101 Switching Protocols。 ここから先、この TCP 接続の上を流れるバイトは、もう HTTP ではありません。
サーバー側のログです。
--- クライアントから来たハンドシェイク ---
GET / HTTP/1.1
host: 127.0.0.1:9040
user-agent: curl/8.12.1
accept: */*
connection: Upgrade
upgrade: websocket
sec-websocket-version: 13
sec-websocket-key: dGhlIHNhbXBsZSBub25jZQ==
--- 101 を返した(Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=)---
Sec-WebSocket-Accept は何をしているのか
暗号でも認証でもありません。
SHA1(クライアントが送った Key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11") を Base64
この固定文字列は RFC 6455 に書いてあり、誰でも知っています。
目的は「相手が本当に WebSocket を理解しているサーバーか」を確かめることだけです。 古いプロキシやキャッシュが、中身を理解しないまま
101を返してしまう事故を防ぐためです。
上の s3pPLMBiTxaQ9kYGzzhZRbK+xOo= は、RFC 6455 の本文に載っている例と完全に一致します。 仕様どおりに実装できている証拠なので、自分で書いたときはここを見比べてください。
本物のクライアントで繋ぐ
Node.js 22 には WebSocket が組み込みで入っています。
open した
サーバー側のログです。
--- クライアントから来たハンドシェイク ---
GET / HTTP/1.1
host: 127.0.0.1:9040
connection: upgrade
upgrade: websocket
sec-websocket-key: JSmrBuuEnzw07vf8HDHEsg==
sec-websocket-version: 13
sec-websocket-extensions: permessage-deflate; client_max_window_bits
accept: */*
accept-language: *
sec-fetch-mode: websocket
user-agent: node
pragma: no-cache
cache-control: no-cache
accept-encoding: gzip, deflate
--- 101 を返した(Accept: KTS4lyfLCWt00l2iqakPg1rjVQ0=)---
--- 生のフレーム 8 バイト ---
81 82 62 a5 cc 83 0a cc
{
FIN: 1,
opcode: '0x1',
masked: 1,
'長さ': 2,
'マスク鍵': '62a5cc83',
'中身': 'hi'
}
フレームを1バイトずつ読む
ws.send('hi') の2文字が、8バイトになっています。 中身を見ます。
| バイト | 16進 | 2進 | 意味 |
|---|---|---|---|
| 0 | 81 | 1000 0001 | FIN=1(これで最後)/ opcode=0x1(テキスト) |
| 1 | 82 | 1000 0010 | MASK=1(マスクあり)/ 長さ=2 |
| 2〜5 | 62 a5 cc 83 | マスク鍵(毎回ランダム) | |
| 6〜7 | 0a cc | 本体。鍵とXORして戻すと hi |
0a cc は hi には見えません。 0x0a ^ 0x62 = 0x68 = 'h'、0xcc ^ 0xa5 = 0x69 = 'i' です。
主な opcode です。
| opcode | 意味 |
|---|---|
0x0 | 続き(前のフレームの続き) |
0x1 | テキスト(UTF-8) |
0x2 | バイナリ |
0x8 | 切断 |
0x9 | Ping |
0xA | Pong |
深追いはここまでにします。 断片化、permessage-deflate の圧縮、Ping/Pong のタイマー、閉じ方の作法――全部あります。
だから本番では
wsパッケージを使ってください。 ここで自作する意味は「中身がバイナリのフレームであると知る」ことだけです。 それを知っていると、curlでデバッグできない理由も、プロキシで詰まる理由も分かります。
マスクは何のためか
クライアント → サーバーのフレームには、必ずマスクが要ります。 逆方向は不要です。
これはセキュリティのためです。 マスクが無いと、攻撃者が中身を完全に制御できるバイト列を、 古いプロキシに「HTTPリクエストのように見せかけて」流し込めてしまいます。 毎回ランダムな鍵でXORすることで、送るバイト列を狙って作れなくしています。
サーバーは止めておきます。
done
📸 スクリーンショット3:
curl -sN -i http://127.0.0.1:9030/eventsの出力と、101 Switching Protocolsが返っているcurl -siの出力。この2つを並べて残す
⑧ 4つの判断表 — どれをいつ使うか
全部書いて、全部測りました。並べます。
性質の比較
| ショートポーリング | ロングポーリング | SSE | WebSocket | |
|---|---|---|---|---|
| 方向 | 双方向(毎回リクエスト) | 双方向(毎回リクエスト) | サーバー→client のみ | 双方向 |
| 接続の数(1人あたり) | 0(都度張って切る) | 1本を握り続ける | 1本を握り続ける | 1本を握り続ける |
| 60秒のリクエスト数(実測) | 59回 | 7回 | 1回 | 1回 |
| 無駄だった割合(実測) | 89.8% | 0.0% | 0% | 0% |
| 実装の手間(サーバー) | ほぼゼロ | 中(res を溜める) | 小(res.write するだけ) | 大(ライブラリ必須) |
| 実装の手間(client) | 小(setInterval) | 中(ループと再接続) | 極小(new EventSource) | 中(再接続を自分で書く) |
| プロキシとの相性 | 完璧(ただのGET) | タイムアウトに注意 | 良い(ただのHTTP) | 要設定(Upgrade を通す設定が必要) |
| 再接続 | 要らない(毎回新規) | 自分で書く | ブラウザが自動(+ Last-Event-ID) | 自分で書く |
| HTTP/2 以上での多重化 | される | される | される(同一接続に相乗り) | されない(専用のTCP接続) |
| ブラウザの同時接続制限 | 影響あり | HTTP/1.1 だと6本まで | 同左(HTTP/2 なら解消) | 影響を受けにくい |
| バイナリ | 送れる | 送れる | 送れない(テキストのみ) | 送れる |
curl でデバッグ | できる | できる | できる | 101 までしか見えない |
選び方は3行
1. 更新が1分に1回で足りるなら、ショートポーリングで十分です。 59回 → 1回になれば無駄はほぼ消えます。 上の表の「89.8%」は1秒間隔だから出た数字です。 実装ゼロ、プロキシの心配ゼロ、再接続の心配ゼロ。捨てる理由がありません。
2. サーバーから通知したいだけなら、SSE です。 通知・進捗バー・株価・ログのライブ表示・AIの逐次出力。全部これで足ります。 再接続がブラウザに入っているのが決定的です。自分で書くと必ずバグります。
3. 双方向が本当に要るときだけ、WebSocket です。 共同編集、ゲーム、対戦、音声。 「ユーザーの操作を毎秒サーバーへ流す」必要がある場合。 それ以外は要りません。
やりがちな間違い
| 間違い | なぜ違うか |
|---|---|
| チャットだから WebSocket | 送信は普通の POST で足ります。受信だけなら SSE で終わり |
| リアルタイムだから WebSocket | 「リアルタイム」の中身を秒で言えるか。5秒でよければポーリング |
| ポーリングは古い | 古くありません。一番壊れにくい方法です |
| SSE は使われていない | 主要なAIチャットの逐次表示はほぼSSEです。地味なだけで現役 |
| WebSocket なら速い | 速いのは2回目以降です。最初のハンドシェイクは HTTP 1往復ぶん遅い |
| SSE も WebSocket も自動で再接続する | SSEだけです。WebSocket は自分で書きます |
全部に共通する、⑥で見た問題
SSE も WebSocket も、ロングポーリングと同じ「接続を持ち続ける」問題を抱えています。
| 気にすること | 対処 |
|---|---|
| サーバーを1台増やしたら通知が届かない | 接続している台と、書き込みを受けた台が違う。Redis の Pub/Sub などで台を跨いで配る |
| デプロイのたびに全員切れる | 正常です。再接続が入っていれば問題にならない(=SSEが楽な理由) |
| プロキシに切られる | 30秒に1回、意味の無いデータ(SSEなら : ping\n\n)を流して黙らせる |
| 同時接続の上限 | OSのファイルディスクリプタ上限。ulimit -n の既定 1024 はすぐ足りなくなる |
1台で動かしているうちは、どれも同じに見えます。 差が出るのは2台目からです。
つまずいたところ
1. data イベントを1件のメッセージだと思っていた
これが全部の始まりです。 開発中は1回の write が1回の data になっていたので、気づけませんでした。 本番で件数が増えた瞬間、JSON.parse が Unexpected non-whitespace character で落ちました。 ③で 200回 → 17回 を目で見て、やっと納得しました。data の切れ目に意味はありません。
2. 改行区切りにしたのに、まだ壊れた
チャットの本文に改行が入っていました。 Shift+Enter を許した日に発生しました。 ③の line-break.mjs で再現したとおり、2件送って3件になります。 JSON.stringify すれば \n はエスケープされるので割れませんが、 「エスケープを忘れない」に頼る設計は、いつか忘れます。 長さプレフィックスに変えました。
3. ss を見たら 0.0.0.0:9001 になっていた
server.listen(9001) と書いて、IPアドレスを省略していました。 これはVMの全部のネットワークで待ち受けます。 ブリッジ接続にしていたら、LAN内から届きます。 練習用のサーバーには必ず '127.0.0.1' を書いてください。 私はこれを ② を書きながら直しました。
4. UDPで「1件も落ちなかった」ので、UDPは信頼できると思いかけた
127.0.0.1 には物理層がありません。 落ちようがない経路で測っていました。 recvBufferSize: 2048 に絞ったら、同じ localhost で 9.3% 消えました。 そして、送った側には何のエラーも出ていません。 これが一番怖いところです。
5. curl で SSE を見たら、何も出ずに固まった
-N を付けていませんでした。 curl は既定で出力をバッファリングします。 -N(--no-buffer)を付けると、届いた端から出ます。 同じ理由で、サーバー側に nginx を挟むと proxy_buffering off; が要ります。 私は最初「SSEが動かない」と思いましたが、動いていて、見えていなかっただけでした。
6. curl で WebSocket のハンドシェイクを投げたら、ターミナルが返ってこなくなった
101 を返した時点で、それはもう HTTP ではありません。 curl はいつ終わるか分からないので、待ち続けます。Ctrl+C で抜けられますが、 -m 3 を最初から付けてください。 私は3回 Ctrl+C を押してから気づきました。
7. WebSocket サーバーが ECONNRESET で落ちた
Error: read ECONNRESET
at TCP.onStreamRead (node:internal/stream_base_commons:216:20)
Emitted 'error' event on Socket instance
socket.on('error', ...) を書いていませんでした。 upgrade イベントで受け取る socket は生のソケットで、エラーハンドラが無いとプロセスごと落ちます。 クライアントが process.exit() で乱暴に切っただけで、サーバー全体が死にました。
socket.on('error', (e) => console.log('[ソケットエラー]', e.code));
生のソケットを触るときは、必ず error を拾ってください。 例外ではなく、通常運転です。
8. ロングポーリングを PHP のサーバーで試して、サイト全体が止まった
同時に開いていたタブが10枚ほどで、他のページが全部開かなくなりました。 PHP-FPM は 1接続 = 1プロセスです。⑥の表のとおり、待たせている間ずっとワーカーを1つ占有します。 Node.js で同じことをしても平気なのは、待っている接続がイベントループの1エントリでしかないからです。 「ロングポーリング/SSE を入れるか」は、言語とサーバー構成の話です。 コードの話ではありません。
後片づけ
まず、走りっぱなしのサーバーが無いか確認します。
(何も出なければOK)
残っていたら止めます。
終了コード: 1
1 は「該当なし」です。 何も残っていなかったということなので、正常です。
もう一度確認します。
0
作業フォルダを消します。
chat-server.mjs len-client.mjs line-client.mjs sse-server.mjs udp-client2.mjs
echo-client.mjs len-server.mjs line-server.mjs udp-client.mjs udp-server.mjs
echo-server.mjs long-poll.mjs lp-run.mjs udp-server2.mjs ws-client.mjs
naive-client.mjs naive-server.mjs short-poll.mjs ws-server.mjs line-break.mjs
中身を見てから消してください。
(空、または他の記事のフォルダ)
rm -rf は戻せません。 パスを打つ前に ls で必ず確認します。
netcat を入れた人は、残しておいて構いません。 nc は「ポートが開いているか」を確かめる道具として、この先も使います。
まとめ — 理解できたこと
- OSI の7層は暗記するものではない。 使うのは「いま困っているのはどの層か」の切り分けだけ
- 実際に動いているのは TCP/IP の4層。 7層は地図、4層が実物
curl -wの DNS / TCP / TLS / firstbyte の4つの数字で、遅い層が1発で分かる。 アプリのコードを見るのは最後- HTTP も WebSocket も SSE も、
sock.write()の上の「決めごと」でしかない。 管そのものは同じ - TCP はストリーム。200回
writeしてdataは17回。writeの回数とdataの回数に関係は無い - まとまるだけでなく、割れもする。
dataの切れ目に意味を求めた瞬間にコードは壊れる - 区切りは自分で決める。 改行区切りは簡単だが、中身に改行が入ると2件に割れる(実測で2件が3件に)
- 長さプレフィックスなら壊れない。 改行入りも30000文字も、
data4回で200件ちょうど組み立てられた - 最後に「箱」が空かどうかが、フレーミングが合っている証拠
- UDP は TCP の逆。区切りは保つが、届く保証は無い(5000 send = 5000 message、ただし受信バッファを絞ると 9.3% 消えた)
- UDP で落ちても、送った側にエラーは1つも出ない。 抜けの検出はアプリの仕事
- DNS・動画・ゲーム・QUIC が UDP なのは、遅れて届くくらいなら捨てたいから
- 1秒ポーリングは 60秒で59回、うち53回が空振り(89.8%が無駄)。 1000人なら1時間に354万回
- ポーリング間隔 N 秒の平均遅延は N/2 秒。 遅延を半分にするとリクエストは2倍。間隔を縮める方向は間違い
- ロングポーリングは同じ60秒で7回、空振り0回。遅延は変わらない
- 代償は「接続を持ち続けること」(
waiting: 3、ssでも3本)。PHP-FPM や同期フレームワークでは死ぬ - プロキシに切られる前に、25秒あたりで自分から一度返す
- SSE は
text/event-streamなだけのHTTPレスポンス。curl -Nで全部読める。区切りは空行 - SSE の再接続はブラウザに入っている(
retry:とLast-Event-ID)。これが自分で書くと必ずバグる部分 - WebSocket は
101 Switching Protocolsでプロトコルが乗り換わる。 そこから先はHTTPではない Sec-WebSocket-Acceptは暗号ではない。 古いプロキシの誤動作を防ぐための確認- フレームは長さプレフィックス方式(③でやったもの)。
ws.send('hi')は8バイトになり、本体はXORでマスクされている - 結論は3行。通知だけなら SSE。双方向が要るときだけ WebSocket。1分に1回でよいならポーリングで十分
参考リンク
- Node.js 公式: net(TCPのソケット)
- Node.js 公式: dgram(UDP)
- Node.js 公式: http(
upgradeイベントを含む) - MDN: Server-sent events を使う
- MDN: EventSource
- MDN: WebSocket
- RFC 6455: The WebSocket Protocol
- RFC 9293: Transmission Control Protocol(TCP。RFC 793 の後継)
- RFC 768: User Datagram Protocol
- man7.org: socket(2) — ソケットのシステムコール
- roadmap.sh: Computer Science
次に読む
この記事は 【深掘り】コンピュータ科学 の 22 / 25 本目です。
上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。
全体の順路は はじめに にあります。
roadmap.sh のどこをやっているか
- TCP はストリームで区切りが無い
- ポーリング / SSE / WebSocket を実測で選ぶ
この記事は、上の項目を実際に手を動かして確かめる回です。

コメント