結論

IT の「コネクション」は、2つのプログラムが通信を始める前に結ぶ「やり取り用の通り道」です。TCP なら3回のあいさつ(3ウェイハンドシェイク)で作られ、データベースなら、その上に認証とサーバー側の受け持ちプロセスまで用意されます。作るたびに時間がかかるので、アプリは作ったコネクションを使い回します。その使い回しの仕組みが「コネクションプール」です。

この記事でわかること

  • TCP・HTTP・データベース(DB)で「コネクション」が指すものの違いと、ss で状態(ESTAB・TIME-WAIT・CLOSE-WAIT)を見る方法
  • PostgreSQL 16 で、毎回接続する場合とプールで使い回す場合の時間差(1回あたり約7ms と約0.15ms)と、pgbench での処理数の差
  • コネクションが残り続ける問題(閉じ忘れ・idle in transaction・CLOSE-WAIT)を再現したときのエラーの原文と直し方

2026年10月29日更新|Ubuntu 24.04・PostgreSQL 16.15・psycopg 3.3.6・Chromium 153で実行確認

この記事で実際に動かしたもの:自分専用のネットワーク名前空間(ip netns)の中で、Python の小さな TCP サーバーと HTTP サーバー、PostgreSQL 16.15 を動かし、tcpdump でコネクションの確立と切断のパケットを、ss でコネクションの状態を記録しました。さらに、psycopg 3.3.6 と psycopg_pool 3.3.3 で「毎回接続」と「プールで使い回す」を300回ずつ測り、pgbench でも同じ比較をしたうえで、閉じ忘れたコネクションで接続数の上限に達する様子と、プールの中で切れたコネクションのエラーを再現しています。

「コネクションが足りない」「DB のコネクションを閉じ忘れている」「コネクションプールを入れましょう」。開発の会話では、コネクションという言葉がいろいろな場面で出てきます。ところが、ネットワークの話をしているときと、データベースの話をしているときでは、指しているものの範囲が少しずつ違います。最初に、アプリがデータベースを使うときに重なっているコネクションの関係を図で示します。

flowchart TD
    A[アプリのスレッド] -->|借りる・返す| P[コネクションプール]
    P --> C[DBコネクション<br>認証済みの会話]
    C --> T[TCPコネクション<br>3ウェイハンドシェイク]
    T --> S[DBサーバーの<br>受け持ちプロセス]

よく調べられることの答えを先にまとめます。

知りたいこと 答え 詳しい節
コネクションとは 通信を始める前に、2者の間に結ぶ論理的な通り道。終わったら閉じる コネクションとは(ふだんの意味とITの意味)
TCP のコネクションとは SYN・SYN-ACK・ACK の3回で確立し、FIN で閉じる。送信元と宛先の IP・ポートの4つで1本が決まる TCPコネクションの一生
DB コネクションとは TCP の上で認証を済ませ、DB サーバーに受け持ちのプロセスができた状態。PostgreSQL では1本につき1プロセス DBのコネクションとは
コネクションプールとは 作った DB コネクションを閉じずに取っておき、次の処理に貸し出す仕組み コネクションプールとは
コネクションを作るのにかかる時間 手元の PostgreSQL(パスワード認証)で1回約7ms。使い回すと約0.03〜0.15ms DBコネクションを作るコストを実測
コネクションとセッションの違い 分野ごとに定義が違う。DB では「1本のコネクション=1セッション」として扱われることが多い よくある質問
コネクションが残り続ける原因 閉じ忘れ・トランザクションの終わらせ忘れ・相手が閉じたのにこちらが閉じない(CLOSE-WAIT) コネクションが残り続ける問題
今あるコネクションの確かめ方 Linux は ss、Windows は Get-NetTCPConnection、DB は pg_stat_activity、ブラウザは開発者ツール 自分で確かめる:今あるコネクションを数える

確認環境:Ubuntu 24.04.5 LTS(カーネル 6.18、2 CPU・メモリ 8GB の共有マシン)で、ホストのネットワーク設定に触れないよう、自分用のネットワーク名前空間 t234 を作り、その中の 127.0.0.1 だけで実験しました。PostgreSQL は Ubuntu のパッケージの 16.15 を使い、initdb で作業用のフォルダー(/dev/shm/t234)に専用のデータベースクラスターを作って、max_connections=20・log_connections=on で起動しています。アプリ側は Python 3.13.18 と psycopg 3.3.6・psycopg_pool 3.3.3(作業用フォルダーの venv)、負荷試験は pgbench 16.15、パケットの記録は tcpdump 4.99.4(.deb を作業用フォルダーに展開して使用)、状態の確認は iproute2 の ss、HTTP の確認は curl 8.5.0 と Chromium 153.0.8010.12(Chrome for Testing を playwright 1.63.0 から操作)です。数値はこの共有マシンでの測定で、ほかの作業と同時に動いているため、絶対値よりも「何倍違うか」を見てください。HikariCP の既定値、Windows の Get-NetTCPConnection、Chrome の開発者ツールの画面は、それぞれの公式ドキュメントで確かめた範囲だけを書いています。図は mermaid-cli 11.16.0 で描画を確かめました(確認日 2026年10月29日)。

本記事の内容は、ご自由にお使いください。
ご利用の際は、出典として本ページへのリンクを記載いただけますようお願いします。

(記載例)出典:株式会社RJC「コネクションとは|TCP・DB接続・コネクションプールを実測で解説」

コネクションとは(ふだんの意味とITの意味)

この節では、「コネクション」という言葉がふだんの会話と IT でどう違うかと、IT の中でも場面ごとに何を指すかが分かります。

コネクション(connection)は「つながり・接続」という意味の英語です。IT では、通信する2つのプログラムの間に、やり取りを始める前に結んでおく論理的な通り道を指します。線が物理的に1本引かれるわけではなく、両側のコンピューターが「今この相手と話している」という情報(相手の住所、どこまで届いたかの番号など)をそれぞれ覚えている状態のことです。

電話にたとえると分かりやすくなります。番号を押して相手が出たら「もしもし」と確かめ合い(確立)、話し(やり取り)、終わったら切ります(切断)。話している間は、相手を毎回名乗り直さなくても会話が続きます。コネクションも同じで、一度結べば、そのあとのデータには「どの会話の続きか」が分かる情報だけを付ければ済みます。

場面 「コネクション」が指すもの 例 気をつけること
ふだんの言葉 人とのつながり、つて。「コネ」の元の言葉 「業界にコネクションがある」 IT の会話で出てきたら、ほぼ通信の意味
電気・機械 部品どうしの接続、つなぎ目 コネクター、配線の接続 物理的な接続。IT の「コネクション」は論理的なもの
ネットワーク(TCP) 2つのソケットの間に確立された通信路 ブラウザと Web サーバー、アプリと DB の間の TCP IP アドレスとポートの組で1本が決まる
Web(HTTP) HTTP の要求と応答を運ぶ TCP(や QUIC)のコネクション keep-alive で同じコネクションを使い回す HTTP 自体は要求ごとに完結する(ステートレス)
データベース 認証を済ませた DB サーバーとの会話の単位 JDBC の Connection、psycopg の connect() DB サーバー側のメモリやプロセスを1本ずつ使う
アプリの設計 作ったコネクションを貯めて貸し出す仕組み コネクションプール(HikariCP・psycopg_pool・PgBouncer) 上限の決め方と、返し忘れに注意

コネクション型とコネクションレス型

通信の方式は、最初にコネクションを結ぶかどうかで2つに分かれます。TCP はコネクション型、UDP はコネクションレス型の代表です。

コネクション型(TCP など)

送る前に相手と確立のやり取りをする

届いたかの確認・再送・順番の並べ直しをする

Web・メール・DB・SSH など、欠けると困る通信

コネクションレス型(UDP など)

確立せずに、いきなりデータを送る

届いたかの確認はしない(必要ならアプリが行う)

DNS の問い合わせ・音声・動画・ゲームなど、速さを優先する通信

この記事では、開発でよく話題になるコネクション型、特に TCP と、その上に乗る HTTP・データベースのコネクションを扱います。

TCPコネクションの一生(確立・やり取り・切断)

この節では、TCP のコネクションが確立されてから閉じられるまでに、実際にどんなパケットが流れるかが分かります。

TCP のコネクションは、SYN → SYN-ACK → ACK の3つのパケットで確立し(3ウェイハンドシェイク)、FIN を送り合って閉じます。名前空間の中の 127.0.0.1:9000 で待ち受ける Python のサーバーに、クライアントが接続して「ping」を送り、「pong」を受け取って閉じるまでを tcpdump で記録しました(-S でシーケンス番号を絶対値で表示)。

$ tcpdump -i lo -nn -S 'tcp port 9000'
11:24:58.096884 IP 127.0.0.1.55300 > 127.0.0.1.9000: Flags [S], seq 171911330, win 65495, options [mss 65495,sackOK,TS val 1295482225 ecr 0,nop,wscale 10], length 0
11:24:58.096895 IP 127.0.0.1.9000 > 127.0.0.1.55300: Flags [S.], seq 1929235469, ack 171911331, win 65483, options [mss 65495,sackOK,TS val 1714497956 ecr 1295482225,nop,wscale 10], length 0
11:24:58.096906 IP 127.0.0.1.55300 > 127.0.0.1.9000: Flags [.], ack 1929235470, win 64, options [nop,nop,TS val 1295482225 ecr 1714497956], length 0
11:24:58.097056 IP 127.0.0.1.55300 > 127.0.0.1.9000: Flags [P.], seq 171911331:171911336, ack 1929235470, win 64, options [nop,nop,TS val 1295482225 ecr 1714497956], length 5
11:24:58.097060 IP 127.0.0.1.9000 > 127.0.0.1.55300: Flags [.], ack 171911336, win 64, options [nop,nop,TS val 1714497956 ecr 1295482225], length 0
11:24:58.097072 IP 127.0.0.1.9000 > 127.0.0.1.55300: Flags [P.], seq 1929235470:1929235475, ack 171911336, win 64, options [nop,nop,TS val 1714497956 ecr 1295482225], length 5
11:24:58.097074 IP 127.0.0.1.55300 > 127.0.0.1.9000: Flags [.], ack 1929235475, win 64, options [nop,nop,TS val 1295482225 ecr 1714497956], length 0
11:24:58.297211 IP 127.0.0.1.55300 > 127.0.0.1.9000: Flags [F.], seq 171911336, ack 1929235475, win 64, options [nop,nop,TS val 1295482425 ecr 1714497956], length 0
11:24:58.297291 IP 127.0.0.1.9000 > 127.0.0.1.55300: Flags [F.], seq 1929235475, ack 171911337, win 64, options [nop,nop,TS val 1714498156 ecr 1295482425], length 0
11:24:58.297312 IP 127.0.0.1.55300 > 127.0.0.1.9000: Flags [.], ack 1929235476, win 64, options [nop,nop,TS val 1295482425 ecr 1714498156], length 0

10個のパケットのうち、データ(ping と pong の5バイトずつ)を運んだのは2個だけで、残りの8個はコネクションを作る・確かめる・閉じるためのものです。小さなデータを1回だけ送るたびにコネクションを作り直すと、この「付き添い」の分だけ手間が増えます。流れを4段階に分けると次のとおりです。

1

接続したいと伝える(SYN)

クライアントが、自分の開始番号(seq 171911330)を付けて SYN を送る。送信元のポート 55300 は OS が自動で選んだもの。

Flags [S]

2

受け入れて番号を返す(SYN-ACK)

サーバーは「171911331 から受け取る」と ack で答え、自分の開始番号も伝える。ここで MSS やウィンドウの大きさも取り決める。

Flags [S.]

3

確立(ACK)とやり取り

クライアントが ACK を返すと、両側で ESTABLISHED(確立済み)になる。以降のデータは番号で順番と抜けを確かめながら運ばれる。

Flags [.] と [P.]

4

閉じる(FIN)

先に閉じた側が FIN を送り、相手も FIN を返す。今回はサーバーの FIN と ACK が1つのパケットにまとまり、3個で終わった。

Flags [F.]

1本のコネクションは「送信元 IP・送信元ポート・宛先 IP・宛先ポート」の4つの組で見分けられます。同じサーバーの 9000 番に何本つないでも、クライアント側のポートが毎回違う(55300・55302・55306…)ので、別々のコネクションとして扱われます。この名前空間でクライアントが使うポートの範囲は、次のとおりでした。

$ cat /proc/sys/net/ipv4/ip_local_port_range
32768	60999

つまり、1つの宛先(IP とポート)に向けて同時に持てるクライアント側のコネクションは、この範囲の約2万8千本が目安になります。後で見る TIME-WAIT がたまると、この範囲を使い切ることがあります。TCP の細かな落とし穴(区切りが無い・40ms の遅延など)は、関連記事「TCPの落とし穴8選|TIME_WAIT・40ms遅延の正体」で扱っています。

ssでコネクションの状態を見る(ESTAB・TIME-WAIT・CLOSE-WAIT)

この節では、Linux の ss コマンドで、今あるコネクションとその状態、持ち主のプロセスを確かめる方法が分かります。

ss -tanp を実行すると、TCP のコネクションが状態・自分側の住所・相手側の住所・持ち主のプロセスと一緒に一覧で出ます。-t は TCP、-a は待ち受けも含めて全部、-n は名前に変換しない、-p はプロセスを表示する、という意味です。上のサーバーとクライアントがつながっている最中に実行した結果です。

$ ss -tanp '( sport = :9000 or dport = :9000 )'
State  Recv-Q Send-Q Local Address:Port  Peer Address:Port Process
LISTEN 0      8          127.0.0.1:9000       0.0.0.0:*     users:(("python3",pid=32435,fd=3))
ESTAB  0      0          127.0.0.1:9000     127.0.0.1:40198 users:(("python3",pid=32435,fd=4))
ESTAB  0      0          127.0.0.1:40198    127.0.0.1:9000  users:(("python3",pid=32439,fd=3))

1本のコネクションが、サーバー側(9000 → 40198)とクライアント側(40198 → 9000)の2行で表示されています。同じマシンの中で通信しているので、両端が1台に見えています。LISTEN の行は「接続を待っている窓口」で、まだコネクションではありません。サーバーは接続を受け付けるたびに、新しいソケット(fd=4)を作って ESTAB の行を増やします。

クライアントが閉じた直後に、もう一度見た結果です。

$ ss -tan '( sport = :9000 or dport = :9000 )'
State     Recv-Q Send-Q Local Address:Port  Peer Address:Port
LISTEN    0      8          127.0.0.1:9000       0.0.0.0:*
TIME-WAIT 0      0          127.0.0.1:40198    127.0.0.1:9000

$ ss -tano state time-wait
Recv-Q Send-Q Local Address:Port  Peer Address:Port Process
0      0          127.0.0.1:40198    127.0.0.1:9000 timer:(timewait,59sec,0)

先に閉じた側(ここではクライアント)に、TIME-WAIT が約60秒残ります。-o を付けると残り時間(59sec)が見えます。遅れて届いたパケットを、次に同じポートを使うコネクションが取り違えないための待ち時間で、異常ではありません。ただし、短いコネクションを大量に作っては閉じると、TIME-WAIT が積み上がります。後の節で PostgreSQL に300回接続し直したあと、この名前空間の TIME-WAIT は約300本に増えていました。

ss の表示 意味 どちら側に出る たくさんあったら
LISTEN 接続を待っている窓口 サーバー 待ち受けているポートの数。普通はそのまま
SYN-SENT SYN を送って返事待ち クライアント 相手が応答しない。ファイアウォールや相手の停止を疑う
ESTAB 確立済み。データをやり取りできる 両方 使っているコネクションの数。上限やプールの大きさと比べる
FIN-WAIT-2 自分は閉じた。相手の FIN 待ち 先に閉じた側 相手が閉じていない。相手側の CLOSE-WAIT と対になる
TIME-WAIT 閉じ終わった後の待ち時間(約60秒) 先に閉じた側 短いコネクションを作り直しすぎ。使い回しを検討
CLOSE-WAIT 相手は閉じた。自分のプログラムが閉じるのを待っている 後から閉じる側 プログラムの閉じ忘れ。自然には消えない

状態ごとの本数をまとめて見たいときは、次の1行が便利です。PostgreSQL への接続を300回作り直した直後の名前空間で実行しました。

$ ss -tan | awk 'NR>1{print $1}' | sort | uniq -c
      2 ESTAB
      1 LISTEN
   1495 TIME-WAIT

ESTAB が2行(1本のコネクションの両端)しかないのに、TIME-WAIT は1,495本ありました。この直前までに、毎回接続のベンチマークを何度か流していたためです。「今つながっている数」は少なくても、「最近作っては捨てたコネクションの跡」がこれだけ残る、という実例です。

HTTPのコネクション(keep-aliveと使い回し)

この節では、Web の通信で同じコネクションがどう使い回されているかを、curl とブラウザの記録で確かめられます。

HTTP/1.1 では、1本の TCP コネクションで複数の要求を順番に送れます(持続的接続、いわゆる keep-alive)。名前空間の中の 127.0.0.1:8080 に、Python の http.server(protocol_version を HTTP/1.1 に設定)を置き、curl で2つのファイルを続けて取得しました。

$ curl --noproxy '*' -sv http://127.0.0.1:8080/a.txt http://127.0.0.1:8080/b.txt
*   Trying 127.0.0.1:8080...
* Connected to 127.0.0.1 (127.0.0.1) port 8080
> GET /a.txt HTTP/1.1
< HTTP/1.1 200 OK
* Connection #0 to host 127.0.0.1 left intact
* Found bundle for host: 0x5638803a3b80 [serially]
* Can not multiplex, even if we wanted to
* Re-using existing connection with host 127.0.0.1
> GET /b.txt HTTP/1.1
< HTTP/1.1 200 OK
* Connection #0 to host 127.0.0.1 left intact

「Re-using existing connection」とあり、2つ目の要求も Connection #0 で送られています。要求に Connection: close を付けると、サーバーは応答のあとにコネクションを閉じ、curl は2本目を作り直しました。

$ curl --noproxy '*' -sv -H 'Connection: close' http://127.0.0.1:8080/a.txt http://127.0.0.1:8080/b.txt
(前半は同じ)
* Connection 0 seems to be dead
* Closing connection
*   Trying 127.0.0.1:8080...
* Connected to 127.0.0.1 (127.0.0.1) port 8080
> GET /b.txt HTTP/1.1
> Connection: close
< HTTP/1.1 200 OK
* Connection #1 to host 127.0.0.1 left intact

サーバーのログで、相手のポート番号を比べると違いがはっきりします。使い回したときは2つの要求が同じポート 52420 から届き、閉じたときは 52434 と 52440 の別々のコネクションから届いています。

('127.0.0.1', 52420) GET /a.txt HTTP/1.1
('127.0.0.1', 52420) GET /b.txt HTTP/1.1
('127.0.0.1', 52434) GET /a.txt HTTP/1.1
('127.0.0.1', 52440) GET /b.txt HTTP/1.1

ブラウザは複数のコネクションを並べて使う

Chromium 153 で、画像2つと fetch 2つを読み込む小さなページを開き、開発者ツールと同じ仕組み(Chrome DevTools Protocol の Network.responseReceived)で、要求ごとのコネクション ID と「使い回したか」を記録しました。

要求 コネクション ID 使い回し(connectionReused) サーバーが見た相手のポート
index.html353true55500
a.txt(画像)353true55500
b.txt(画像)395false55504
a.txt?2(fetch)401false55520
b.txt?2(fetch)407false55532
favicon.ico353true55500

6つの要求に対して、ブラウザは4本のコネクションを開き、ID 353 の1本で3つの要求を運んでいました。HTTP/1.1 では1本のコネクションで同時に1つの要求しか運べないため、ブラウザは同じサーバーに数本を並べて開き、空いたものから使い回します。HTTP/2 と HTTP/3 では、1本のコネクションの中で複数の要求を同時に流せるので、開く本数はさらに少なくなります。

DBのコネクションとは(PostgreSQLでは1接続=1プロセス)

この節では、データベースの「コネクション」が TCP のコネクションとどう違い、DB サーバーの中で何が起きているかが分かります。

DB のコネクションは、TCP(または Unix ドメインソケット)でつないだうえで、ユーザー名とパスワードの認証を済ませ、使うデータベースを決めた「会話」です。PostgreSQL の公式ドキュメントには、「同時に複数の接続を扱うため、接続ごとに新しいプロセスを起動する(fork する)」と書かれています(Architectural Fundamentals)。1本のコネクションを作ると、DB サーバーの中に1つのプロセスが生まれるということです。

Python から PostgreSQL に1本つないで、トランザクションを開いたまま待たせ、その間に3つの方法で同じコネクションを見ました。

import psycopg, time, os
c = psycopg.connect("host=127.0.0.1 dbname=t234db user=app password=apppass application_name=hold-demo")
print('client pid', os.getpid(), 'backend pid', c.info.backend_pid)
c.execute("select 1")
time.sleep(30)
client pid 378 backend pid 380

$ ps -o pid,ppid,user,cmd --ppid 31188
  PID  PPID USER     CMD
  380 31188 postgres postgres: app t234db 127.0.0.1(40350) idle in transaction
31189 31188 postgres postgres: checkpointer
31190 31188 postgres postgres: background writer
31192 31188 postgres postgres: walwriter
31193 31188 postgres postgres: autovacuum launcher
31194 31188 postgres postgres: logical replication launcher

$ ss -tnp state established '( dport = :5432 or sport = :5432 )'
Recv-Q Send-Q Local Address:Port  Peer Address:Port Process
0      0          127.0.0.1:40350    127.0.0.1:5432  users:(("python",pid=378,fd=3))
0      0          127.0.0.1:5432     127.0.0.1:40350 users:(("postgres",pid=380,fd=9))

PostgreSQL の親プロセス(PID 31188)の下に、PID 380 の「postgres: app t234db 127.0.0.1(40350)」というプロセスができています。これがこのコネクションの受け持ちです。ss で見える TCP のコネクション(40350 ⇔ 5432)の、サーバー側の持ち主も同じ PID 380 です。DB の中からは pg_stat_activity で見えます。

SELECT pid, usename, application_name, client_addr, client_port, state, backend_type
FROM pg_stat_activity ORDER BY backend_type, pid;
  pid  | usename  | application_name | client_addr | client_port |        state        |         backend_type
-------+----------+------------------+-------------+-------------+---------------------+------------------------------
 31193 |          |                  |             |             |                     | autovacuum launcher
 31190 |          |                  |             |             |                     | background writer
 31189 |          |                  |             |             |                     | checkpointer
   380 | app      | hold-demo        | 127.0.0.1   |       40350 | idle in transaction | client backend
   386 | postgres | psql             |             |          -1 | active              | client backend
 31194 | postgres |                  |             |             |                     | logical replication launcher
 31192 |          |                  |             |             |                     | walwriter
(7 rows)

application_name を接続文字列に入れておくと、どのアプリのコネクションかが pg_stat_activity で一目で分かります。client_port が -1 の行は、Unix ドメインソケットでつないだ psql です。log_connections を on にしたサーバーのログには、1本のコネクションの一生が4行で残っていました(日付は省略)。

11:25:27.467 JST [328] LOG:  connection received: host=127.0.0.1 port=40346
11:25:27.474 JST [328] LOG:  connection authenticated: identity="app" method=scram-sha-256 (/dev/shm/t234/pg/data/pg_hba.conf:3)
11:25:27.474 JST [328] LOG:  connection authorized: user=app database=t234db application_name=psql
11:25:27.476 JST [328] LOG:  disconnection: session time: 0:00:00.009 user=app database=t234db host=127.0.0.1 port=40346

TCP の接続を受けてから、パスワード認証(scram-sha-256)が通るまでに7ms かかっています。TCP の3ウェイハンドシェイクは、この前の一瞬で終わっています。DB のコネクションで時間がかかるのは、TCP そのものよりも、プロセスの準備と認証のほうです。次の節で数字にします。PostgreSQL の接続数の確認方法を詳しく知りたい場合は、関連記事「PostgreSQL接続数の確認|pg_stat_activityの見方と対処」で扱っています。

DBコネクションを作るコストを実測する

この節では、DB のコネクションを毎回作る場合と使い回す場合で、1回の処理にかかる時間がどれだけ違うかが分かります。

psycopg 3.3.6 で select 1 を300回ずつ実行し、1回ごとの時間を測りました。「毎回接続」は接続 → 実行 → 切断を1回とし、「使い回す」は接続済みの1本で実行だけ、「プールから借りる」は psycopg_pool の ConnectionPool(5本)から借りて返すまでを1回としています。20回の暖機のあと、同じ測定を3回繰り返しました。

def per(dsn):
    def f():
        with psycopg.connect(dsn) as c:
            c.execute("select 1").fetchone()
    return f

pool = ConnectionPool(TCP_SCRAM, min_size=5, max_size=5, open=True)
def p():
    with pool.connection() as c:
        c.execute("select 1").fetchone()
やり方 中央値(3回の範囲) p95(3回の範囲) 300回の合計
毎回接続(TCP・パスワード認証 scram-sha-256)7.1〜7.9ms10.9〜19.8ms2.3〜3.0秒
毎回接続(TCP・認証なし trust)2.6〜3.1ms4.5〜6.0ms0.9〜1.0秒
毎回接続(Unix ドメインソケット・trust)2.3〜3.8ms3.4〜9.5ms0.8〜1.4秒
1本を使い回す0.03〜0.08ms0.05〜0.14ms10〜27ms
プールから借りる(5本)0.13〜0.18ms0.27〜0.44ms49〜70ms
7.1ms毎回接続(パスワード認証)中央値。3回で7.1〜7.9ms
0.16msプールから借りる中央値。約45分の1
0.015msTCP の接続だけ5432番へ connect して閉じる

パスワード認証つきで毎回接続すると、プールから借りる場合の約45倍、1本を使い回す場合の約100倍以上の時間がかかりました。認証なし(trust)でも約3ms かかるのは、PostgreSQL がコネクションごとにプロセスを用意するためです。scram-sha-256 は、パスワードを安全に確かめるためにわざと計算を重くしているので、さらに4ms ほど増えます。一方、同じ 5432 番に TCP でつないで閉じるだけなら中央値 0.015ms でした。同じマシンの中なので通信の往復はほぼゼロで、ネットワーク越しのサーバーなら、ここに往復の時間(数ms〜数十ms)が何回か加わります。

pgbench で処理数を比べる

PostgreSQL に付いてくる負荷試験の道具 pgbench には、トランザクションごとに接続し直す -C オプションがあります。読み取りだけ(-S)、4クライアント・10秒で比べました。

$ pgbench -h 127.0.0.1 -U app -S -c 4 -j 2 -T 10 t234db
number of transactions actually processed: 577743
latency average = 0.069 ms
tps = 57894.941479 (without initial connection time)

$ pgbench -h 127.0.0.1 -U app -S -c 4 -j 2 -T 10 -C t234db
number of transactions actually processed: 1187
latency average = 33.743 ms
average connection time = 16.528 ms
tps = 118.544043 (including reconnection times)

1秒あたりの処理数(tps)は、接続を保ったままなら約57,895、毎回接続し直すと約119で、約490分の1に落ちました。パスワード認証のない postgres ユーザーで -C を付けた場合は約419 tps(平均接続時間 4.7ms)でした。2 CPU のマシンで4クライアントが同時に接続を作るため、1本あたりの接続時間は単独で測ったときより長くなっています。接続を作る処理は CPU を使うので、同時に多く作るほど遅くなる、という点も覚えておくと役に立ちます。

コネクションプールとは(仕組みと効果)

この節では、コネクションプールの仕組みと、同時アクセスが多いときにプールが DB を守る様子が分かります。

コネクションプールは、作った DB コネクションを閉じずに取っておき、処理が来たら貸し出し、終わったら返してもらう仕組みです。「プール(pool)」は、ためておく場所という意味です。アプリのコードでは「接続して、閉じる」と書いていても、プールを通すと、閉じる操作が「プールに返す」に置き換わります。

1作る時間を省く

認証とプロセスの準備は最初の1回だけ。2回目からは作り済みのコネクションをすぐ使える。前の節の測定で約7ms が約0.16ms になった。

2本数に上限をかける

アプリのスレッドがいくつあっても、DB へのコネクションはプールの上限まで。足りないときは空くまで待たせ、DB の上限を超えないようにする。

3傷んだコネクションを外す

貸す前の確認や、一定時間での作り直しで、サーバー側で切られたコネクションを渡さないようにする(設定しだい)。

30スレッドが同時に来たときの違い

max_connections=20(うち3本は管理者用の予約)のサーバーに、30スレッドが20回ずつ、0.01秒かかるクエリ(select pg_sleep(0.01))を投げました。毎回接続する場合と、上限5本のプールを通す場合の結果です(2回とも同じ傾向)。

毎回接続: 成功 284 失敗 316 所要 3.07秒 remaining connection slots are reserved for roles with the SUPERUSER attribute
プール(max 5): 成功 600 失敗 0 所要 1.33秒
  stats {'connections_num': 5, 'requests_num': 600, 'requests_queued': 595, 'requests_wait_ms': 31866}

毎回接続では600回のうち316回が接続数の上限で失敗し、プールでは5本だけで600回すべてが成功して、しかも速く終わりました。プールの統計を見ると、600回の要求のうち595回は空きを待つ列に並んでいます。待たせてでも本数を抑えたほうが、全員が同時に押し寄せるより速く終わるという結果です。DB サーバーの CPU やメモリには限りがあるので、同時に動かせる仕事の数はコネクションの数ほど増えません。

プールの種類 どこで動く 例 向いている場面
アプリ内のプール アプリのプロセスの中 HikariCP(Java)、psycopg_pool・SQLAlchemy(Python)、各言語の DB ドライバー 常に動き続けるアプリサーバー。まずはこれ
外付けのプール(プロキシ) アプリと DB の間の別プロセス PgBouncer(PostgreSQL)、クラウドの DB プロキシ アプリのプロセスが多い・増減が激しい(サーバーレスなど)
プールなし ― 使い捨てのスクリプト、バッチ 1回の実行でつなぐ回数が少ないとき

アプリ内のプールは、アプリのプロセスごとに作られます。上限10本のプールを持つアプリを8台に増やせば、DB から見たコネクションは最大80本です。台数を増やすときは、プールの上限 × 台数が DB の上限を超えないかを先に計算します。PgBouncer の設定と、上限を超えたときの直し方は、関連記事「PostgreSQL too many clientsの直し方|接続数と接続プール」で扱っています。

コネクションプールの設定の考え方(主な既定値)

この節では、コネクションプールで最初に決める項目と、よく使われるライブラリの既定値が分かります。

プールで決めることは、ほぼ「何本まで持つか」「空きが無いとき何秒待つか」「何分使ったら作り直すか」の3つです。Java で広く使われる HikariCP の公式 README に書かれた既定値を並べます(2026年10月29日時点)。

HikariCP の設定 既定値 意味
maximumPoolSize10使用中と空きを合わせたコネクションの上限
minimumIdlemaximumPoolSize と同じ保とうとする空きの本数。README は設定せずに固定の大きさで使うことを勧めている
connectionTimeout30000ms(30秒)空きを待つ最長時間。超えると SQLException
idleTimeout600000ms(10分)空きのまま置いておく最長時間(minimumIdle が上限より小さいときだけ有効)
maxLifetime1800000ms(30分)1本の最長寿命。DB や途中の機器の制限より数秒短くすることが強く勧められている
keepaliveTime120000ms(2分)空きのコネクションの生存確認の間隔
leakDetectionThreshold0(無効)借りたまま返さない時間がこれを超えるとログに警告を出す

HikariCP の Wiki「About Pool Sizing」は、DB のコネクションは多くの人が思うほど多くは要らず、多すぎると性能がはっきり落ちる、という立場で書かれています。前の節の実験でも、5本のプールが30本の同時接続より速く終わりました。最初は既定の10本前後から始め、待ち時間(psycopg_pool なら requests_wait_ms、HikariCP ならメトリクス)と DB の CPU を見ながら調整するのが堅実です。

  1. 1DB の上限を確かめるPostgreSQL の max_connections は既定で通常100。管理者用に3本予約されている
  2. 2つなぐアプリの台数を数える本番の台数に、デプロイ中に一時的に増える分も足す
  3. 31台あたりの上限を決める台数 × 上限 + 管理用・バッチ用が DB の上限に収まるように
  4. 4待ち時間と寿命を決める待ち時間は利用者が待てる長さより短く。寿命は途中の機器のアイドル切断より短く
  5. 5測って調整する待ちが多いのに DB の CPU に余裕があれば増やす。CPU が張り付いていれば増やしても速くならない

コネクションが残り続ける問題(閉じ忘れ・idle in transaction・CLOSE-WAIT)

この節では、コネクションが閉じられずに残り続けると何が起きるかを、エラーの原文と一緒に確かめられます。

閉じ忘れで接続数の上限に達する

DB のコネクションを閉じずに参照を持ち続けると、1本ずつ DB の枠を埋めていき、やがて新しい接続ができなくなります。リクエストのたびに接続して、閉じずにリストへ入れてしまうコードで再現しました。

leaked = []
def handle(i):
    c = psycopg.connect("host=127.0.0.1 dbname=t234db user=app password=apppass application_name=leak")
    c.execute("select 1")
    leaked.append(c)   # close() を忘れたのと同じ(参照が残り続ける)
18本目で失敗: connection failed: connection to server at "127.0.0.1", port 5432 failed: FATAL:  remaining connection slots are reserved for roles with the SUPERUSER attribute
開いたままの接続: 17

max_connections=20 から、管理者用の予約(superuser_reserved_connections の既定値3)を引いた17本で止まりました。管理者ユーザーでさらに4本つなぐと、21本目で最後の上限に達します。

21 本目: connection failed: connection to server at "127.0.0.1", port 5432 failed: FATAL:  sorry, too many clients already

閉じ忘れていた17本を pg_stat_activity で見ると、すべて idle in transaction になっていました。

 usename  | application_name |        state        | count
----------+------------------+---------------------+-------
 app      | leak             | idle in transaction |    17
 postgres | psql             | active              |     1

idle in transaction:トランザクションの終わらせ忘れ

psycopg 3 は、既定では autocommit が無効で、最初の SQL を実行した時点でトランザクションが始まります。select 1 だけでも、commit か rollback をしない限り「トランザクションの途中で何もしていない」状態が続きます。これが idle in transaction です。行のロックを持ったままになったり、VACUUM が不要になった行を片付けられなくなったりするので、ただの空き(idle)より困った状態です。

PostgreSQL には、この状態が一定時間続いたコネクションを切る設定(idle_in_transaction_session_timeout)があります。app ユーザーに2秒を設定し、トランザクションを開いたまま3秒待ってから次の SQL を送りました。

psycopg.errors.IdleInTransactionSessionTimeout: terminating connection due to idle-in-transaction timeout

サーバーのログには FATAL: terminating connection due to idle-in-transaction timeout が残ります。同じ設定のまま autocommit=True で接続したコネクションは、3秒待ったあとも問題なく select 2 を返しました(transaction_status は INTRANS ではなく IDLE)。直し方は、with 文でコネクションとトランザクションの終わりをはっきりさせることです。

DB コネクションの扱い方

やってはいけない接続して SQL を実行し、close も commit もせずに変数やリストに入れたままにする。例外が出たときの close を書かない
→
代わりにwith psycopg.connect(...) as c: や with pool.connection() as c:、Java なら try-with-resources で、抜けるときに必ず commit/rollback と close(返却)をさせる

psycopg_pool の connection() は、正常終了なら commit、例外なら rollback してからプールに返す(公式ドキュメント)

CLOSE-WAIT:相手が閉じたのにこちらが閉じない

TCP でも、プログラムが閉じ忘れると、コネクションが残り続けます。受け付けたソケットを close せずにリストへ入れてしまうサーバーに、クライアントから3回接続して閉じました。

$ ss -tanp '( sport = :9000 or dport = :9000 )'
State      Recv-Q Send-Q Local Address:Port  Peer Address:Port Process
LISTEN     0      8          127.0.0.1:9000       0.0.0.0:*     users:(("python3",pid=32639,fd=3))
FIN-WAIT-2 0      0          127.0.0.1:55302    127.0.0.1:9000
FIN-WAIT-2 0      0          127.0.0.1:55306    127.0.0.1:9000
FIN-WAIT-2 0      0          127.0.0.1:55318    127.0.0.1:9000
CLOSE-WAIT 1      0          127.0.0.1:9000     127.0.0.1:55318 users:(("python3",pid=32639,fd=6))
CLOSE-WAIT 1      0          127.0.0.1:9000     127.0.0.1:55306 users:(("python3",pid=32639,fd=5))
CLOSE-WAIT 1      0          127.0.0.1:9000     127.0.0.1:55302 users:(("python3",pid=32639,fd=4))

CLOSE-WAIT は「相手からは FIN が届いたが、自分のプログラムがまだ close していない」状態で、プログラムが閉じるかプロセスが終わるまで消えません。持ち主のプロセス(pid=32639)とファイルディスクリプター(fd=4〜6)がそのまま見えるので、どのプログラムの閉じ忘れかを特定できます。サーバーのプロセスを止めると、OS が代わりに閉じ、クライアント側の FIN-WAIT-2 はすべて TIME-WAIT に変わりました。CLOSE-WAIT が増え続けると、最後はファイルディスクリプターの上限(Too many open files)にぶつかります。

プールの中で切れたコネクション(返し忘れ・サーバー側の切断)

この節では、コネクションプールを使っていても起きる2つのつまずきと、その直し方が分かります。

返し忘れでプールが空になる

上限2本のプールから getconn で2本借りたまま返さず、3本目を借りようとしました(待ち時間 timeout=2秒)。

PoolTimeout: couldn't get a connection after 2.00 sec(2.0秒待った)

プールが空になると、DB の上限に達していなくても、アプリは空きを待ち続けてタイムアウトします。DB から見ると「コネクションは少ないのに、アプリが遅い・エラーになる」ように見えるのが特徴です。getconn と putconn を自分で対にするより、with pool.connection() を使うほうが返し忘れが起きません。HikariCP なら leakDetectionThreshold を設定すると、返し忘れの疑いをログで知らせてくれます。

サーバー側で切られたコネクションが残る

プールに1本作ったあと、管理者が pg_terminate_backend でそのコネクションを切りました。DB の再起動や、途中の機器のアイドル切断でも同じことが起きます。プールの check 引数なしと、あり(ConnectionPool.check_connection)で比べた結果です。

[2 check=なし] AdminShutdown: terminating connection due to administrator command
[2 check=あり] 成功 backend_pid 10767 -> 10769

check なしでは、切られたことに気づかないまま切断済みのコネクションを貸し出し、最初の SQL でエラーになりました。check ありでは、貸す前に確認して壊れたものを捨て、新しいコネクション(受け持ちプロセスが 10767 から 10769 に変わった)を渡しています。確認には1往復ぶんの時間がかかるので、HikariCP の keepaliveTime や maxLifetime のように、空いている間に確かめる・寿命で作り直す方法と組み合わせます。

自分で確かめる:今あるコネクションを数える

この節では、自分のパソコンやサーバー、DB、ブラウザで、今あるコネクションをその場で確かめる手順が分かります。

コネクションの問題は、まず「今何本あって、どの状態か」を数えるところから始まります。次の4つのうち、自分の環境に合うものを1つ試すだけで、話がぐっと具体的になります。

1

Linux・WSL のターミナルで1行

ss -tan | awk 'NR>1{print $1}' | sort | uniq -c で状態ごとの本数が出る。特定のポートだけなら ss -tnp state established '( dport = :5432 )'。

この記事で実行済み

2

Windows の PowerShell で1行

Get-NetTCPConnection -State Established で確立済みの TCP コネクションの一覧。-State には TimeWait・CloseWait なども指定できる(Microsoft Learn)。

公式ドキュメントで確認

3

PostgreSQL で1行

psql で SELECT state, count(*) FROM pg_stat_activity WHERE backend_type = 'client backend' GROUP BY state;。上限は SHOW max_connections;。

この記事で実行済み

4

ブラウザの開発者ツールで見る

Chrome で F12 → Network パネル → 一覧の見出し行を右クリック → 「Connection ID」にチェック。同じ ID が並べば、そのコネクションを使い回している。

Chrome DevTools 公式の説明で確認

手順3を、トランザクションを開いたままのコネクションが1本ある状態で実行した結果です。

        state        | count
---------------------+-------
 active              |     1
 idle in transaction |     1
(2 rows)

 max_connections
-----------------
 20
(1 row)

active の1本は、この SQL を実行している psql 自身です。idle in transaction が数分以上続いているコネクションがあれば、前の節の閉じ忘れを疑います。接続を待っているポートを別のプロセスが使っていて起動できない場合は、関連記事「Address already in useの解決方法【Windows・Mac・Linux】」で扱っています。

  • 1ESTAB の本数がプールの上限と台数の積に収まっているか超えていればプールを通っていない接続がある
  • 2CLOSE-WAIT が増え続けていないか増え続けるなら、そのプロセスの閉じ忘れ
  • 3TIME-WAIT が数千本単位でないか短いコネクションの作り直しすぎ。使い回しを検討
  • 4idle in transaction が長く残っていないかcommit/rollback の書き忘れ。タイムアウトも設定する
  • 5application_name でアプリを見分けられるか接続文字列に入れておくと、原因の特定が早くなる

コネクションのよくあるエラーとつまずき(原文つき)

この節では、コネクションまわりで出るエラーの原文から、原因と最初に打つ手が分かります。

エラー・症状(原文) 原因 最初に打つ手
FATAL: sorry, too many clients already PostgreSQL の max_connections に達した pg_stat_activity で持ち主を調べ、閉じ忘れとプールの上限 × 台数を見直す
FATAL: remaining connection slots are reserved for roles with the SUPERUSER attribute 一般ユーザーの枠(上限 − 予約3本)を使い切った 上と同じ。管理者の枠は残っているので psql で調査できる
PoolTimeout: couldn't get a connection after 2.00 sec プールの全コネクションが貸し出し中のまま 返し忘れ(with を使っていない箇所)と、長く借りる処理を探す
terminating connection due to idle-in-transaction timeout トランザクションを開いたまま放置し、サーバーが切った commit/rollback を確実に。読むだけなら autocommit も検討
AdminShutdown: terminating connection due to administrator command サーバー側で切られたコネクションを使った(再起動・強制切断) プールの貸し出し前チェックや寿命(maxLifetime)を設定する
Connection refused 相手のポートで誰も待ち受けていない サーバーが起動しているか、ポート番号と待ち受けアドレスを確かめる
ss に CLOSE-WAIT が増え続ける 相手が閉じたのに、自分のプログラムが close していない ss -tanp で持ち主のプロセスを特定し、close の漏れを直す
ss に TIME-WAIT が数千本 短いコネクションを大量に作っては閉じている HTTP の keep-alive や DB のプールで使い回す

つながらない・途中で切れるときの見分け方(Connection refused・タイムアウト・reset の違い)は、関連記事「Connection refused・Read timed outの違いと直し方」で扱っています。

判断表:コネクションをどう扱うか

この節では、自分の状況から、コネクションの扱い方を1行で選べます。

状況 おすすめ 理由
Web アプリ・API サーバーから DB を使う アプリ内のコネクションプール 毎回接続は1回あたり数ms 余計にかかり、同時アクセスで上限に達する
アプリのプロセスが多い・頻繁に増減する 外付けのプール(PgBouncer など)を足す アプリ内のプールだけだと、プロセス数 × 上限で DB の枠を超える
1日1回のバッチ、使い捨てのスクリプト 1本を開いて使い回し、最後に閉じる プールを用意する手間に見合わない。ループの中で接続し直さない
Web サーバーへ同じ相手に何度も要求する HTTP クライアントを使い回し、keep-alive を有効にする 要求ごとの3ウェイハンドシェイクと TLS の手間を省ける
DB の接続数が上限に近い 上限を上げる前に、閉じ忘れとプールの合計を確かめる PostgreSQL は1本ごとにプロセスを使うので、増やすほど DB が重くなる
ときどき「切られたコネクション」のエラーが出る 貸し出し前チェックか、寿命を途中の機器の切断時間より短くする DB の再起動やアイドル切断のあとも、プールは切断済みのコネクションを持っている

よくある質問

この節では、コネクションについてよく聞かれる疑問に、短く答えます。

Q. コネクションとセッションの違いは何ですか。
A. 分野ごとに定義が違うため、ひと言では決められません。TCP にはコネクションの考え方があり、HTTP では Cookie などで続く状態を慣習的にセッションと呼びます。PostgreSQL では、1本のコネクションに1つのセッション(受け持ちのプロセス)が対応し、ログにも「session time」と出ます。会話で出てきたら「どの層の話か」を確かめると行き違いが減ります。

Q. コネクションとソケットの違いは何ですか。
A. ソケットは、プログラムが通信に使う「口」(OS が用意する出入り口)です。コネクションは、2つのソケットの間に結ばれた通り道です。サーバーでは、待ち受け用のソケット1つ(LISTEN)とは別に、受け付けたコネクションごとに新しいソケットができます。この記事の ss の出力で、fd=3 が待ち受け、fd=4 がコネクション用でした。

Q. コネクションプールは必ず使うべきですか。
A. 常に動いているアプリサーバーから DB を使うなら、使うほうが速く安全です。手元の測定では、パスワード認証つきの接続が1回約7ms、プールからの貸し出しは約0.16ms でした。一方、1回だけ動いて終わるスクリプトでは、1本を開いて使い回せば足ります。

Q. プールの上限は何本にすればよいですか。
A. 決まった正解はありません。DB の上限を、つなぐアプリの台数(デプロイ中に増える分も含む)で割った数が最大値の目安です。HikariCP の既定値は10本で、公式 Wiki は多すぎると性能が落ちると説明しています。待ち時間と DB の CPU を見ながら調整します。

Q. コネクションを閉じ忘れるとどうなりますか。
A. DB では接続数の枠を埋めていき、手元の実験では17本目までで一般ユーザーの枠が尽き、「remaining connection slots are reserved…」で新しい接続ができなくなりました。TCP では CLOSE-WAIT が残り、最後はファイルディスクリプターの上限に達します。

Q. TIME-WAIT がたくさんあるのは異常ですか。
A. TIME-WAIT 自体は、先に閉じた側に約60秒残る正常な状態です。ただ数千本単位でたまっているなら、短いコネクションを作っては閉じる動きが多すぎるサインです。HTTP の keep-alive や DB のプールで使い回すと減ります。

Q. 「コネクションが切れました」と出るのはなぜですか。
A. 相手のサーバーが再起動した、管理者が切断した、途中のファイアウォールやロードバランサーが長く使われていないコネクションを切った、などが主な原因です。プールを使っている場合は、貸し出し前のチェックや、寿命を途中の機器の切断時間より短くする設定で防げます。

Q. Unix ドメインソケットでつなぐと速くなりますか。
A. 同じマシンの中では、手元の測定で TCP(認証なし)と大きな差はありませんでした(中央値はどちらも2〜4ms)。接続の時間の大部分は、DB 側のプロセスの準備と認証だからです。速くしたいなら、つなぎ方を変えるより、コネクションを使い回すほうが効果があります。

Q. HTTP/2 になるとコネクションはどう変わりますか。
A. HTTP/1.1 では1本のコネクションで同時に1つの要求しか運べないため、ブラウザは同じサーバーに数本を並べて開きます(手元の Chromium では6つの要求に4本)。HTTP/2 と HTTP/3 は1本の中で複数の要求を同時に流せるので、少ない本数で済みます。

Q. idle と idle in transaction の違いは何ですか。
A. idle は、つながっているだけで何もしていない状態で、プールの空きコネクションは普通これです。idle in transaction は、トランザクションを開いたまま何もしていない状態で、ロックを持ち続けたり、VACUUM を妨げたりします。後者が長く続くなら、commit/rollback の書き忘れを探します。

まとめ

この節では、この記事の要点を5つにまとめます。

  • コネクションは、通信を始める前に2者の間に結ぶ論理的な通り道です。TCP では SYN・SYN-ACK・ACK で確立し、FIN で閉じます。1本は送信元と宛先の IP・ポートの4つの組で決まります。
  • DB のコネクションは、TCP の上で認証を済ませた会話で、PostgreSQL では1本ごとに受け持ちのプロセスが生まれます。手元ではパスワード認証つきで1回約7ms かかりました。
  • コネクションプールは、作ったコネクションを貸し出して使い回す仕組みで、1回約0.16ms に縮み、30スレッドの同時アクセスでも5本で全件成功しました。
  • コネクションが残り続ける原因は、閉じ忘れ・トランザクションの終わらせ忘れ・CLOSE-WAITです。with 文や try-with-resources で、終わりを必ず書きます。
  • まず数える:ss・Get-NetTCPConnection・pg_stat_activity・ブラウザの Connection ID で、今の本数と状態を確かめてから対策を選びます。

参考・出典

この節では、この記事で確かめた公式の情報源が分かります(いずれも確認日 2026年10月29日)。

本記事の内容は、ご自由にお使いください。
ご利用の際は、出典として本ページへのリンクを記載いただけますようお願いします。

(記載例)出典:株式会社RJC「コネクションとは|TCP・DB接続・コネクションプールを実測で解説」

株式会社RJC ― SI事業・SES事業・AI駆動開発。RJCは一緒に成長を楽しめる会社です。

WE ARE HIRING

RJCで一緒に開発しながら、
成長を楽しみませんか?

RJCは、Web・モバイル・AIを活用した開発プロジェクトで、テックリードやPM・PMOも活躍するシステム開発会社です。会社を知る、待遇を確かめる、話を聞いてみる。気になるところ見てみてください!

  • 127日年間休日
  • 12時間平均残業時間
  • 毎日ガチャ遊びココロも大切にする福利厚生。アマギフなどの賞品ラインナップ!

ほかにも、チケットレストラン、書籍読み放題、2年ごとの慰労報奨(休暇 or 金一封)、11期連続の黒字決算。

ABOUT RJC RJCがどんな会社か知る 考え方、研修、働き方、福利厚生、社員の前職まで。RJCのことが丸わかり! RJC丸わかりページへ JOB DESCRIPTION 仕事内容・待遇を見てみる 仕事内容、給与・待遇、選考の流れ。経験者も未経験も!応募前に知りたいこと、まとめました! 募集要項を見る ENTRY エントリーする エントリーは1〜2分・履歴書不要です。まずは話を聞いてみたい、という方でも歓迎です! エントリーフォームへ

成長のヒミツ、 ぜんぶ丸わかり