<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>トランザクション &#8211; SRA OSS Tech Blog</title>
	<atom:link href="https://www.sraoss.co.jp/tech-blog/tag/a1f0baa7da02933e4f2845bf383250c6/feed/index.xml" rel="self" type="application/rss+xml" />
	<link>https://www.sraoss.co.jp/tech-blog/</link>
	<description>OSS専門の技術ブログ。PostgreSQL、Zabbixを中心に10種類以上のOSSの解説、アップデート情報、運用ヒントを提供。</description>
	<lastBuildDate>Mon, 09 Nov 2026 03:56:47 +0000</lastBuildDate>
	<language>ja</language>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	<generator>https://wordpress.org/?v=7.1.3</generator>

<image>
	<url>https://www.sraoss.co.jp/tech-blog/wp-content/uploads/2018/07/blog-icon-150x150.png</url>
	<title>トランザクション &#8211; SRA OSS Tech Blog</title>
	<link>https://www.sraoss.co.jp/tech-blog/</link>
	<width>32</width>
	<height>32</height>
</image> 
	<item>
		<title>PostgreSQL であなたの UPDATE が終わらない理由 〜トランザクション、ロック、MVCC を実験で理解する〜</title>
		<link>https://www.sraoss.co.jp/tech-blog/pgsql/postgresql-update-lock-wait/</link>
		
		<dc:creator><![CDATA[正野 裕大 (Yuta Masano)]]></dc:creator>
		<pubDate>Tue, 30 Jun 2026 05:21:12 +0000</pubDate>
				<category><![CDATA[PostgreSQL]]></category>
		<category><![CDATA[MVCC]]></category>
		<category><![CDATA[pg_blocking_pids()]]></category>
		<category><![CDATA[トランザクション]]></category>
		<category><![CDATA[ロック]]></category>
		<category><![CDATA[監視ビュー]]></category>
		<guid isPermaLink="false">https://www.sraoss.co.jp/tech-blog/?p=20842</guid>

					<description><![CDATA[アプリケーションから次のようなSQLを実行したのに、なかなか応答が返ってこないことがあります。 UPDATE accounts SET balance = balance - 100 WHERE id = 1; こういう ...]]></description>
										<content:encoded><![CDATA[<p>アプリケーションから次のようなSQLを実行したのに、なかなか応答が返ってこないことがあります。</p>
<pre><code>UPDATE accounts SET balance = balance - 100 WHERE id = 1;
</code></pre>
<p>こういうときに原因の一つとして早めに確認しておきたいものがロック待ちです。ロック待ちとは、あるトランザクションが更新中の行などを、別のトランザクションが同時に変更しようとして、先のトランザクションが終わるまで待っている状態です。PostgreSQLはデータの矛盾を防ぐため、同じ行を複数の処理が同時に勝手に書き換えられないようにします。そのため、後から実行した<code>UPDATE</code>は、必要なロックを取得できるまで待つことがあります。</p>
<p>本記事では、同じ行への<code>UPDATE</code>によってロック待ちが起きる状況を作り、どこを確認すれば原因を切り分けられるのかを説明します。</p>
<p><span id="more-20842"></span></p>
<p>対象読者は、PostgreSQLを使い始めたアプリケーション開発者や運用初心者です。SQLは書けるものの、トランザクション、ロック、MVCC、監視ビューの関係をまだ整理できていない人を想定しています。</p>
<h3>実験の前に</h3>
<p>この実験では、<code>psql</code>のセッションを3つ使います。</p>
<ul>
<li>セッションA:先に行を更新して、ロックを保持する</li>
<li>セッションB:同じ行を更新しようとして待つ</li>
<li>セッションC: PostgreSQLの状態を確認する</li>
</ul>
<p>ここで、実験に入る前にトランザクションについて簡単に整理します。</p>
<p>トランザクションとは、複数のSQL操作をひとまとまりの処理として扱う仕組みです。たとえば、口座Aから100円を引き、口座Bに100円を足す処理を考えます。この2つの更新は、片方だけの成功は許されません。引き落としだけ成功して、入金が失敗すると、データの整合性が崩れるためです。そこで、PostgreSQLでは、関連するSQLを1つのトランザクションとして扱えます。</p>
<p><code>BEGIN</code>を実行すると、トランザクションが始まります。</p>
<pre><code>BEGIN;
</code></pre>
<p>トランザクション内で実行した変更は、<code>COMMIT</code>するまで確定しません。</p>
<pre><code>COMMIT;
</code></pre>
<p><code>COMMIT</code>は、トランザクション内で行った変更を確定する操作です。<code>COMMIT</code> すると、他のセッションからもその変更が見えるようになります。一方、変更を取り消したい場合は<code>ROLLBACK</code>を実行します。</p>
<pre><code>ROLLBACK;
</code></pre>
<p><code>ROLLBACK</code>は、トランザクション内で行った変更を取り消す操作です。<code>ROLLBACK</code>すると、そのトランザクションで実行した更新はなかったことになります。</p>
<p>本記事のロック待ちを理解するうえで重要なのは、次の点です。トランザクション中に<code>UPDATE</code>文の実行が終わっていても、<code>COMMIT</code>または<code>ROLLBACK</code>を実行するまで、トランザクションは終わりません。そして、トランザクションが終わるまで、更新に関係するロックが保持されることがあります。つまり、次のような状態が問題になります。</p>
<pre><code>BEGIN;
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
-- COMMITもROLLBACKもしていない
</code></pre>
<p>この状態では、<code>UPDATE</code> 自体は終わっています。しかし、トランザクションはまだ終わっていません。そのため、別のセッションが同じ行を更新しようとすると、先のトランザクションが終わるまで待つことがあります。</p>
<p>本記事では実験を通して、この「トランザクションが終わっていないために、別の更新が待たされる状態」を意図的に作ります。つまり、単に <code>UPDATE</code>を実行するだけでなく、<code>BEGIN</code>でトランザクションを開始し、あえて <code>COMMIT</code>せずに残す操作が重要になります。</p>
<p>以降の実験では、セッションAがトランザクションを開いたまま行を更新し、セッションBが同じ行を更新しようとして待つ、という流れを何度か使います。</p>
<h2>実験の準備</h2>
<p>まず、検証用のテーブルを作ります。ここでは、口座残高を表す<code>accounts</code>テーブルを使います。</p>
<pre><code>-- accountsテーブルを作成
CREATE TABLE accounts (
  id integer PRIMARY KEY
  , owner_name text NOT NULL
  , balance integer NOT NULL
);

-- データを2件登録
INSERT INTO accounts (id, owner_name, balance)
VALUES
  (1, 'alice', 1000),
  (2, 'bob', 2000);
</code></pre>
<p>初期状態を確認します。</p>
<pre><code>SELECT * FROM accounts ORDER BY id;
 id | owner_name | balance
----+------------+---------
  1 | alice      |    1000
  2 | bob        |    2000
(2 rows)
</code></pre>
<p>以降は各実験を始める前に、セッションAとセッションBで次を実行しておくと安全です。</p>
<pre><code>-- 各実験の前にROLLBACKを実行してトランザクションを終了しておく
-- Session A/B
ROLLBACK;
</code></pre>
<p>すでにトランザクションが終わっている場合は、警告が出ることがあります。その場合でも、この実験では問題ありません。</p>
<p>合わせて、セッションAと セッションBのPIDも確認しておきます。</p>
<pre><code>-- セッションA
SELECT pg_backend_pid();
 pg_backend_pid
----------------
             52
(1 row)


-- セッションB
SELECT pg_backend_pid();
 pg_backend_pid
----------------
             57
(1 row)
</code></pre>
<h2>実験1:同じ行をUPDATEすると片方が待つ</h2>
<h3>この実験で確認すること</h3>
<p>この実験では、同じ行を2つのトランザクションから<code>UPDATE</code>すると、後から実行した <code>UPDATE</code>が待たされることを確認します。ポイントは、先に<code>UPDATE</code>したセッションが<code>COMMIT</code>するまで、後続の <code>UPDATE</code>が進めないことです。</p>
<h3>手順1:セッションAでトランザクションを開始する</h3>
<p>まず、セッションAでトランザクションを開始します。</p>
<pre><code>-- Session A
BEGIN;
</code></pre>
<p>この時点で、セッションAはトランザクションの中に入ります。まだデータは更新していません。</p>
<h3>手順2:セッションAでid = 1の行を更新する</h3>
<p>続けて、セッションAで<code>id = 1</code>の行を更新します。</p>
<pre><code>-- Session A
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
</code></pre>
<p>この<code>UPDATE</code>自体はすぐに終わります。ただし、まだ<code>COMMIT</code>していません。そのため、セッションA のトランザクションは開いたままです。</p>
<p>ここが重要です。<code>UPDATE</code>文の実行が終わっていても、トランザクションが終わっていなければ、PostgreSQL はその更新に関係するロックを保持し続けます。</p>
<h3>手順3:セッションBで同じ行を更新する</h3>
<p>次に、セッションBでもトランザクションを開始します。</p>
<pre><code>-- Session B
BEGIN;
</code></pre>
<p>そのあと、セッションBで同じ<code>id = 1</code>の行を更新します。</p>
<pre><code>-- Session B
UPDATE accounts SET balance = balance - 50 WHERE id = 1;
</code></pre>
<p>この<code>UPDATE</code>は応答が返ってきません。アプリケーションから見ると、「UPDATEが終わらない」状態に見えます。</p>
<h3>なぜ待つのか</h3>
<p>セッションAは、<code>id = 1</code>の行を先に更新しました。しかし、まだ<code>COMMIT</code>も <code>ROLLBACK</code>もしていません。この状態で、セッションBが同じ行を更新しようとすると、PostgreSQLはセッションB の更新をすぐには進めません。セッションAの更新が確定するのか、取り消されるのかがまだ分からないからです。そのため、セッションBはセッションA のトランザクションが終わるのを待ちます。この待ちが、ロック待ちです。</p>
<h3>この実験で分かったこと</h3>
<p>同じ行を同時に更新しようとすると、後から実行した<code>UPDATE</code>が待つことがあります。ただし、画面上で <code>UPDATE</code>が返ってこないだけでは、SQLの処理が重いのか、ロックを待っているのかは分かりません。</p>
<p>次は、PostgreSQLの中でその待ち状態を確認します。</p>
<h2>実験2: pg_stat_activityで何を待っているかを確認する</h2>
<h3>この実験で確認すること</h3>
<p>この実験では、待っているセッションが本当にロック待ちなのかを確認します。使うのは、<code>pg_stat_activity</code>です。<code>pg_stat_activity</code> は、PostgreSQLに接続している各セッションの状態を確認できるビューです。</p>
<h3>確認するSQL</h3>
<p>セッションCから、次のSQLを実行します。</p>
<pre><code>-- Session C
SELECT
  pid
  , state
  , wait_event_type
  , wait_event
  , xact_start
  , query_start
  , query
FROM
  pg_stat_activity
WHERE
  datname = current_database()
  AND pid &lt;&gt; pg_backend_pid()
  AND query LIKE '%UPDATE accounts%'
ORDER BY
  query_start;
 pid |        state        | wait_event_type |  wait_event   |          xact_start           |          query_start          |                           query
-----+---------------------+-----------------+---------------+-------------------------------+-------------------------------+-----------------------------------------------------------
  52 | idle in transaction | Client          | ClientRead    | 2026-06-15 05:57:26.539576+00 | 2026-06-15 05:57:26.541089+00 | UPDATE accounts SET balance = balance - 100 WHERE id = 1;
  57 | active              | Lock            | transactionid | 2026-06-15 05:57:31.885276+00 | 2026-06-15 05:57:31.886839+00 | UPDATE accounts SET balance = balance - 50 WHERE id = 1;
(2 rows)
</code></pre>
<h3>まず確認する列</h3>
<p>ここで最初に確認する列は、次の3つです。</p>
<ul>
<li><code>state</code></li>
<li><code>wait_event_type</code></li>
<li><code>wait_event</code></li>
</ul>
<p><code>state</code>は、そのセッションの大まかな状態を示します。ここでは、<code>pid = 57</code>のセッションBは <code>state = 'active'</code>になっています。これは、PostgreSQLがそのSQLを処理中として扱っているという意味です。ただし、<code>active</code><br />
だからといって、CPUを使って計算し続けているとは限りません。何かを待っていても、SQLの実行中であれば<br />
<code>active</code>と表示されることがあります。</p>
<p>そこで、<code>wait_event_type</code>と<code>wait_event</code>を合わせて確認します。</p>
<h3>結果の読み方</h3>
<p>セッションBの行を確認すると、次のようになっています。</p>
<pre><code>wait_event_type = Lock
wait_event      = transactionid
</code></pre>
<p><code>wait_event_type = Lock</code>は、ロックを待っていることを示します。<code>wait_event = transactionid</code> は、別のトランザクションが終わるのを待っていることを示します。この例では、セッションBがセッションAのトランザクション終了を待っています。</p>
<p>つまり、セッションBの<code>UPDATE</code>は、検索や計算に時間がかかっているのではありません。ロック待ちで止まっています。</p>
<h3>この実験で分かったこと</h3>
<p><code>UPDATE</code>が返ってこないときは、まず<code>pg_stat_activity</code>を確認します。特に、<code>state</code><br />
だけで判断しないことが重要です。<code>wait_event_type</code>と<br />
<code>wait_event</code>を合わせて確認すると、そのセッションが何を待っているのかを確認できます。</p>
<p>次は、どのセッションが待たせているのかを確認します。</p>
<h2>実験3: pg_blocking_pids()で待たせている相手を探す</h2>
<h3>この実験で確認すること</h3>
<p>この実験では、待っているセッションを止めている相手を特定します。待っている側を、ここではウェイターと呼びます。待たせている側を、ここではブロッカーと呼びます。</p>
<p>PostgreSQLでは、<code>pg_blocking_pids()</code>を使うと、当該PIDのブロッカーPIDを確認できます。</p>
<h3>確認するSQL</h3>
<p>セッションCで次のSQLを実行します。<code>pg_blocking_pids()</code>は引数に指定したPIDのブロッカーPIDの配列を返します。</p>
<pre><code>-- Session C
WITH activity AS (
  SELECT
    pid
    , state
    , wait_event_type
    , wait_event
    , pg_blocking_pids(pid) AS blocking_pids
    , query
  FROM
    pg_stat_activity
  WHERE
    datname = current_database()
    AND pid &lt;&gt; pg_backend_pid()
)
SELECT
  *
FROM
  activity
WHERE
  query LIKE '%UPDATE accounts%'
ORDER BY
  pid;
 pid |        state        | wait_event_type |  wait_event   | blocking_pids |                           query
-----+---------------------+-----------------+---------------+---------------+-----------------------------------------------------------
  57 | active              | Lock            | transactionid | {52}          | UPDATE accounts SET balance = balance - 50 WHERE id = 1;
  52 | idle in transaction | Client          | ClientRead    | {}            | UPDATE accounts SET balance = balance - 100 WHERE id = 1;
</code></pre>
<h3>結果の読み方</h3>
<p><code>pid = 57</code>の行を確認すると、<code>blocking_pids</code>が<code>{52}</code>になっています。これは、<code>pid = 57</code> のセッションが、<code>pid = 52</code>のセッションで待たされているという意味です。</p>
<p>この例では、次の関係になります。</p>
<pre><code>ウェイター（待っている側）:     pid = 57
ブロッカー（待たせている側）:   pid = 52
</code></pre>
<p>つまり、<code>pid = 57</code>のSQLだけを確認しても原因は分かりません。次に確認すべきなのは、ブロッカーの<code>pid = 52</code>の状態です。</p>
<h2>実験4: idle in transactionはロックを保持し得る状態</h2>
<h3>この実験で確認すること</h3>
<p>この実験では、<code>idle in transaction</code>の意味を確認します。<code>idle in transaction</code>は、トランザクションの中にいるが、現在はSQL を実行していない状態です。何もしていないように見えても、トランザクションが終わっていなければ、ロックを保持していることがあります。</p>
<h3>状況の確認</h3>
<p>ここまでの状態では、セッションAが<code>id = 1</code>の行を更新し、まだ<code>COMMIT</code>していません。セッションB は、同じ行を更新しようとして待っています。</p>
<p>セッションCから次のSQLを実行します。実験3のSQLに表示列(<code>xact_start</code>, <code>state_change</code>)を追加しています。</p>
<pre><code>-- Session C
WITH activity AS (
  SELECT
    pid
    , state
    , wait_event_type
    , wait_event
    , pg_blocking_pids(pid) AS blocking_pids
    , xact_start
    , state_change
    , query
  FROM
    pg_stat_activity
  WHERE
    datname = current_database()
    AND pid &lt;&gt; pg_backend_pid()
)
SELECT
  *
FROM
  activity
WHERE
  query LIKE '%UPDATE accounts%'
ORDER BY
  xact_start NULLS LAST;
 pid |        state        | wait_event_type |  wait_event   | blocking_pids |          xact_start           |         state_change          |                           query
-----+---------------------+-----------------+---------------+---------------+-------------------------------+-------------------------------+-----------------------------------------------------------
  52 | idle in transaction | Client          | ClientRead    | {}            | 2026-06-15 05:57:26.539576+00 | 2026-06-15 05:57:26.542127+00 | UPDATE accounts SET balance = balance - 100 WHERE id = 1;
  57 | active              | Lock            | transactionid | {52}          | 2026-06-15 05:57:31.885276+00 | 2026-06-15 05:57:31.886842+00 | UPDATE accounts SET balance = balance - 50 WHERE id = 1;
(2 rows)
</code></pre>
<h3>結果の読み方</h3>
<p><code>pid = 52</code>のセッションは、<code>state = 'idle in transaction'</code>になっています。</p>
<p>これは、次の状態を意味します。</p>
<pre><code>トランザクションはまだ開いている
ただし、現在はSQLを実行していない
</code></pre>
<p>また、この行では<code>wait_event_type = Client</code>、<code>wait_event = ClientRead</code>になっています。これは、PostgreSQL がクライアントから次の命令を待っていることを示します。つまり、セッションAはデータベース内部でロックを待っているのではなく、クライアント側から次の SQL、<code>COMMIT</code>、または<code>ROLLBACK</code>が送られるのを待っている状態です。</p>
<p>この状態でも、セッションAはロックを解放していません。ロックは、トランザクションが<code>COMMIT</code>または <code>ROLLBACK</code>で終わるまで保持されます。そのため、セッションBは待ち続けます。</p>
<h3>なぜ問題になりやすいのか</h3>
<p><code>idle in transaction</code>は、アプリケーションの作りによって長引くことがあります。</p>
<p>たとえば、次のような処理です。</p>
<ul>
<li>トランザクションを開始したあとに、外部APIの応答を待つ</li>
<li>トランザクションを開始したあとに、ユーザー入力を待つ</li>
<li>例外が発生したのに、<code>ROLLBACK</code>しないまま接続を残す</li>
</ul>
<p>これらは、ロックを保持したまま待ち時間を伸ばす原因になります。</p>
<h3>実務で確認する列</h3>
<p>実務で<code>idle in transaction</code>を見つけたときは、すぐにセッションを終了する前に、まず次の列を確認します。</p>
<ul>
<li><code>xact_start</code></li>
<li><code>state_change</code></li>
<li><code>query</code></li>
<li><code>application_name</code></li>
<li><code>client_addr</code></li>
</ul>
<p>特に<br />
<code>xact_start</code><br />
が古い場合は、長時間トランザクションが開いたままになっている可能性があります。ただし、セッションを強制終了すると、アプリケーション側ではエラーになります。注文更新や残高更新の途中であれば、業務処理にも影響します。そのため、まずはどのアプリケーション、どの接続元、どの処理がトランザクションを開いたままにしたのかを特定することが重要です。</p>
<h3>timeout設定について</h3>
<p><code>idle in transaction</code>を長時間残したくない場合は、<code>idle_in_transaction_session_timeout</code> を使う方法もあります。この設定は、トランザクション内で何もしていないセッションを、指定時間後に切断します。ただし、切断された側のアプリケーションにはエラーとして見えます。本番環境で使う場合は、事前に影響を確認する必要があります。</p>
<h3>この実験で分かったこと</h3>
<p><code>idle in transaction</code><br />
は、何もしていない安全な状態とは限りません。トランザクションが終わっていなければ、ロックを保持し続けることがあります。ロック待ちを調べるときは、待っている側だけでなく、待たせている側の<br />
<code>state</code>と<code>xact_start</code>を確認します。</p>
<p>次は、通常のロック待ちとデッドロックの違いを確認します。</p>
<h2>実験5:通常のロック待ちとデッドロックは違う</h2>
<h3>この実験で確認すること</h3>
<p>ここまでの実験では、セッションBがセッションAを一方的に待っていました。この場合、セッションAが<code>COMMIT</code>または <code>ROLLBACK</code>すれば、セッションBは進めます。これは通常のロック待ちです。</p>
<p>一方で、デッドロックは違います。デッドロックは、複数のトランザクションが互いに相手を待ってしまい、どちらも先へ進めなくなる状態です。</p>
<h3>実験前の準備</h3>
<p>セッションAとセッションBの両方で<code>ROLLBACK</code>を実行し、前の実験の状態を終わらせます。</p>
<pre><code>-- Session A / Session B
ROLLBACK;
</code></pre>
<h3>手順1:セッションAがid = 1を更新する</h3>
<pre><code>-- Session A
BEGIN;
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
</code></pre>
<p>セッションAは、<code>id = 1</code>の行を更新します。まだ<code>COMMIT</code>はしません。</p>
<h3>手順2:セッションBがid = 2を更新する</h3>
<pre><code>-- Session B
BEGIN;
UPDATE accounts SET balance = balance - 50 WHERE id = 2;
</code></pre>
<p>セッションBは、<code>id = 2</code>の行を更新します。こちらも、まだ<code>COMMIT</code>はしません。</p>
<p>この時点では、セッションAとBは別々の行を更新しているため、互いに待っていません。</p>
<h3>手順3:セッションAがid = 2を更新しようとする</h3>
<p>次に、セッションAが<code>id = 2</code>の行を更新しようとします。</p>
<pre><code>-- Session A
UPDATE accounts SET balance = balance + 100 WHERE id = 2;
</code></pre>
<p><code>id = 2</code>は、すでにセッションBが更新しています。そのため、セッションAはセッションBのトランザクション終了を待ちます。</p>
<p>この時点では、まだデッドロックではありません。セッションAが、セッションBを一方的に待っているだけです。</p>
<h3>手順4:セッションBがid = 1を更新しようとする</h3>
<p>最後に、セッションBが<code>id = 1</code>の行を更新しようとします。</p>
<pre><code>-- Session B
UPDATE accounts SET balance = balance + 50 WHERE id = 1;
</code></pre>
<p><code>id = 1</code>は、すでにセッションAが更新しています。そのため、セッションBはセッションAのトランザクション終了を待ちます。</p>
<p>これで、次の状態になります。</p>
<pre><code>セッションAは、セッションBを待っている
セッションBは、セッションAを待っている
</code></pre>
<p>これがデッドロックです。</p>
<h3>デッドロック時のエラー</h3>
<p>PostgreSQLはデッドロックを検出すると、どちらか一方のトランザクションを中止します。</p>
<p>エラーの例です。</p>
<pre><code>ERROR:  deadlock detected
DETAIL:  Process 57 waits for ShareLock on transaction 2317; blocked by process 52.
Process 52 waits for ShareLock on transaction 2318; blocked by process 57.
HINT:  See server log for query details.
CONTEXT:  while updating tuple (0,1) in relation "accounts"
</code></pre>
<p>このエラーが出たあとは、エラーになったトランザクションはそのまま続けられません。次の実験へ進む前に、セッションAとBの両方で <code>ROLLBACK</code>を実行します。</p>
<pre><code>-- Session A / Session B
ROLLBACK;
</code></pre>
<h3>通常のロック待ちとの違い</h3>
<p>通常のロック待ちは、ブロッカー側が終われば解消します。一方、デッドロックでは、互いに相手を待っています。そのままではどちらも進めません。</p>
<p>そのため、PostgreSQL はどちらか一方を中止して、待ち続ける状態を解消します。どちらのトランザクションが中止されるかをアプリケーション側で決め打ちしてはいけません。 デッドロックで失敗した場合は、失敗したSQLだけを再実行するのではなく、トランザクション全体を最初からやり直す必要があります。</p>
<h3>デッドロックを減らす考え方</h3>
<p>複数行を更新する処理では、更新する順序をそろえることが基本です。たとえば、ある処理は<code>id = 1</code>のあとに <code>id = 2</code>を更新し、別の処理は<code>id = 2</code>のあとに<code>id = 1</code>を更新すると、デッドロックが起きやすくなります。</p>
<p>更新順序を決められるなら、常に同じ順序で更新します。たとえば、常に<code>id</code>の小さい順に更新するなどが考えられます。</p>
<h3>lock_timeoutについて</h3>
<p>通常のロック待ちが長すぎる場合の安全装置として、<code>lock_timeout</code>があります。</p>
<pre><code>SET lock_timeout = '3s';
</code></pre>
<p><code>lock_timeout</code>は、ロックを取得できない状態が指定時間を超えたときに、そのSQL をエラーにします。これは、デッドロックを検出する設定ではありません。ロック待ちが長くなりすぎたSQLを失敗させるための設定です。また、<code>statement_timeout</code> との関係にも注意が必要です。<code>statement_timeout</code>は、SQL全体の実行時間に対する制限です。<code>lock_timeout</code><br />
は、ロック取得待ちに対する制限です。<code>statement_timeout</code>が<br />
<code>lock_timeout</code>以下に設定されていると、ロック待ち専用のエラーより先に <code>statement_timeout</code>が発生します。ロック待ちを切り分けたい場合は、両者の値を分けて設定します。</p>
<h3>この実験で分かったこと</h3>
<p>通常のロック待ちは、ブロッカー側が終われば解消します。一方、デッドロックは、互いに相手を待つため、そのままでは解消しません。PostgreSQL はどちらか一方のトランザクションを中止します。アプリケーションでは、デッドロックやロックタイムアウトで失敗した場合に、トランザクション全体をやり直せるようにしておく必要があります。</p>
<p>次は、書き込みではなく、読み取りがどう見えるのかを確認します。</p>
<h2>実験6:通常のSELECTは止まらない</h2>
<h3>この実験で確認すること</h3>
<p>ここまでの実験では、<code>UPDATE</code>同士の待ちを見てきました。では、あるセッションが行を更新してまだ <code>COMMIT</code>していないとき、別のセッションがその行を<code>SELECT</code>するとどうなるのでしょうか。</p>
<p><code>FOR UPDATE</code>などを付けない通常の<code>SELECT</code>は、多くの場合、更新中の行を待たずに結果を返します。これは、PostgreSQL が、読み取り時点で見えてよい行の版を選んで読みます。この仕組みをMVCC (Multi-Version Concurrency Control) と呼びます。日本語では、多版型同時実行制御と呼ばれます。</p>
<p>以降では、「見えてよい行の版を読む仕組み」を簡単に説明します。</p>
<h3>実験前の準備</h3>
<p>セッションAとセッションBの両方で<code>ROLLBACK</code>を実行します。</p>
<pre><code>-- Session A / Session B
ROLLBACK;
</code></pre>
<h3>手順1:セッションAでid = 1を更新する</h3>
<p>まず、更新前の値を確認します。</p>
<pre><code>-- Session A
SELECT id, owner_name, balance FROM accounts WHERE id = 1;
 id | owner_name | balance
----+------------+---------
  1 | alice      |    1000
(1 row)
</code></pre>
<p>セッションAでトランザクションを開始します。</p>
<pre><code>-- Session A
BEGIN;
</code></pre>
<p>次に、<code>id = 1</code>の残高を<code>999</code>に更新します。</p>
<pre><code>-- Session A
UPDATE accounts SET balance = 999 WHERE id = 1;
</code></pre>
<p>ここでも、まだ<code>COMMIT</code>はしません。つまり、セッションAの変更はまだ確定していません。</p>
<h3>手順2:セッションBで通常のSELECTを実行する</h3>
<p>セッションBから、<code>BEGIN</code>でトランザクションを開始して、同じ行を読み取ります。</p>
<pre><code>-- Session B
BEGIN;
SELECT id, owner_name, balance FROM accounts WHERE id = 1;
 id | owner_name | balance
----+------------+---------
  1 | alice      |    1000
(1 row)
</code></pre>
<p>セッションBの<code>SELECT</code>はロック待ちになりません。また、セッションAが更新した<code>balance = 999</code>も見えません。セッションB からは、最後に<code>COMMIT</code>済みの値である<code>1000</code>が見えます。</p>
<h3>なぜ止まらないのか</h3>
<p>セッションAの<code>UPDATE</code>は、まだ<code>COMMIT</code>されていません。もし、セッションBから未コミットの <code>999</code>が見えてしまうと、あとからセッションAが <code>ROLLBACK</code>したときに困ります。存在しなかった変更を読んだことになるからです。そのため、PostgreSQLは通常の <code>SELECT</code>に対して、未コミットの変更を見せません。代わりに、読み取り時点で見えてよい、古い行の版を返します。</p>
<p>PostgreSQLのデフォルト設定では、各SQLを実行するたびに、その時点で <code>COMMIT</code>済みのデータを読みます。この設定を、トランザクション分離レベルの<br />
<code>Read Committed</code><br />
と呼びます。トランザクション分離レベルとは、あるトランザクションから、他のトランザクションの変更をどこまで見せるかを決める設定です。</p>
<h3>SELECT FOR UPDATEは待つ</h3>
<p>ただし、すべての<code>SELECT</code>が待たないわけではありません。<code>SELECT FOR UPDATE</code> は、読み取った行をあとで更新する前提でロックしようとします。</p>
<pre><code>-- Session B
SELECT id, owner_name, balance FROM accounts WHERE id = 1 FOR UPDATE;
</code></pre>
<p>この場合は、セッションAのトランザクション終了を待ちます。通常の <code>SELECT</code>は、見えてよい行の版を読めるため、止まらないことが多いです。一方、<code>SELECT FOR UPDATE</code> は行をロックしようとするため、更新中の行と競合します。</p>
<h3>この実験で分かったこと</h3>
<p>PostgreSQLでは、未コミットの変更は通常の<code>SELECT</code>から見えません。この実験では、通常の <code>SELECT</code>は、更新中の行を待たずに、見えてよい行の版を読みます。一方、<code>SELECT FOR UPDATE</code> は行をロックしようとするため、対象の行が他のトランザクションで更新中の場合は、待つことがあります。</p>
<p>次は、ロック待ちしていた<code>UPDATE</code>が再開したときに、どの条件で更新されるのかを確認します。</p>
<h2>実験7: UPDATEは待ったあとにWHEREを再確認する</h2>
<h3>この実験で確認すること</h3>
<p>この実験では、ロック待ちしていた<code>UPDATE</code>が再開したときの動きを確認します。重要なのは、ロック待ちしていた <code>UPDATE</code>が、ロック待ちの前に見えていた古い行をそのまま更新するわけではない、という点です。</p>
<p>PostgreSQLのデフォルト設定では、ロック待ちが終わったあと、更新後の行に対して<code>WHERE</code>条件をもう一度確認します。</p>
<h3>実験前の準備</h3>
<p>セッションAとセッションBの両方で<code>ROLLBACK</code>を実行します。</p>
<pre><code>-- Session A / Session B
ROLLBACK;
</code></pre>
<h3>手順1:セッションAがid = 1を更新する</h3>
<p>まず、更新前の値を確認します。</p>
<pre><code>-- Session A
SELECT id, owner_name, balance FROM accounts WHERE id = 1;
 id | owner_name | balance
----+------------+---------
  1 | alice      |    1000
(1 row)
</code></pre>
<p>セッションAでトランザクションを開始します。</p>
<pre><code>-- Session A
BEGIN;
</code></pre>
<p>次に、<code>id = 1</code>の残高を<code>1000</code>にします。ここでは、同じ行を更新中の状態にするため、<code>id = 1</code>の残高を <code>1000</code>に更新します。値は変わりませんが、<code>UPDATE</code>は実行されるため、この行はセッションA のトランザクションが終わるまで、他の更新と競合する状態になります。</p>
<pre><code>-- Session A
UPDATE accounts SET balance = 1000 WHERE id = 1;
</code></pre>
<p>まだ<code>COMMIT</code>はしません。</p>
<h3>手順2:セッションBが条件付きUPDATEを実行する</h3>
<p>セッションBでトランザクションを開始します。</p>
<pre><code>-- Session B
BEGIN;
</code></pre>
<p>次に、残高が<code>500</code>以上の場合だけ、<code>50</code>減らす<code>UPDATE</code>を実行します。</p>
<pre><code>-- Session B
UPDATE accounts
SET balance = balance - 50
WHERE id = 1
  AND balance &gt;= 500
RETURNING *;
</code></pre>
<p>この<code>UPDATE</code>は待ちます。 セッションAが同じ<code>id = 1</code>の行を更新して、まだ<code>COMMIT</code>していないからです。</p>
<h3>手順3:セッションAが残高を400にしてCOMMITする</h3>
<p>セッションBが待っている間に、セッションAで同じ行の残高を<code>400</code>にします。</p>
<pre><code>-- Session A
UPDATE accounts SET balance = 400 WHERE id = 1;
</code></pre>
<p>そのあと、セッションAのトランザクションを確定します。</p>
<pre><code>-- Session A
COMMIT;
</code></pre>
<p>これで、セッションBの待ちが解除されます。</p>
<h3>セッションBの結果</h3>
<p>セッションBの<code>UPDATE</code>は再開します。ただし、セッションB は、ロック待ちの前に見えていた行をそのまま更新するわけではありません。セッションAが<code>COMMIT</code>した後の行に対して、<code>WHERE</code> 条件をもう一度確認します。</p>
<p>この時点で、<code>id = 1</code>の<code>balance</code>は<code>400</code>です。セッションBの条件は次のとおりでした。</p>
<pre><code>WHERE id = 1
  AND balance &gt;= 500
</code></pre>
<p><code>balance = 400</code>なので、<code>balance &gt;= 500</code>は成り立ちません。そのため、セッションBの<code>UPDATE</code>は0 行更新になります。</p>
<pre><code> id | owner_name | balance
----+------------+---------
(0 rows)
</code></pre>
<h3>この動きが重要な理由</h3>
<p>アプリケーションで避けたいのは、先に<code>SELECT</code>で値を確認し、その結果だけを前提にして、あとから無条件に <code>UPDATE</code>する書き方です。</p>
<pre><code>BEGIN;
SELECT balance FROM accounts WHERE id = 1;

UPDATE accounts
SET balance = balance - 500
WHERE id = 1;
COMMIT;
</code></pre>
<p>この書き方では、<code>SELECT</code>してから <code>UPDATE</code>するまでの間に、別のトランザクションが同じ行を更新する可能性があります。つまり、アプリケーションが事前に見た残高と、実際に <code>UPDATE</code>する時点の残高が同じとは限りません。</p>
<p>残高不足を防ぎたいなら、更新してよい条件を<code>UPDATE</code>の<code>WHERE</code>に入れます。</p>
<pre><code>BEGIN;
UPDATE accounts
SET balance = balance - 500
WHERE id = 1
  AND balance &gt;= 500;
COMMIT;
</code></pre>
<p>このSQLは、<code>UPDATE</code>する時点の<code>balance</code>が<code>500</code>以上の場合だけ、残高を減らします。1行更新されれば成功です。0 行なら、残高不足として扱えます。</p>
<h3>分離レベルを上げる場合</h3>
<p>トランザクション分離レベルを<code>Repeatable Read</code>や<br />
<code>Serializable</code><br />
に上げる方法もあります。ただし、その場合は競合する更新を検出して、トランザクションがエラーになることがあります。分離レベルを上げる場合は、失敗した SQLだけでなく、トランザクション全体を最初から再試行できる設計が必要です。</p>
<h3>この実験で分かったこと</h3>
<p>ロック待ちしていた<code>UPDATE</code>は、ロック待ちが終わったあとに <code>WHERE</code>条件を再確認します。そのため、並行更新に強い処理にしたい場合は、事前の<code>SELECT</code>結果だけに頼らず、<code>UPDATE</code> の<code>WHERE</code>に更新条件を入れることが重要です。</p>
<h2>実務での切り分け手順</h2>
<p>ここまでの実験で、ロック待ちの見方を段階的に確認しました。実務でも、まず見るところは同じです。</p>
<p><code>UPDATE</code>が返ってこないときは、最初に<code>pg_stat_activity</code>を確認します。ここで見るのは、待っているセッションの <code>state</code>、<code>wait_event_type</code>、<code>wait_event</code>です。<code>wait_event_type</code>が <code>Lock</code>であれば、そのセッションはロック待ちしている可能性が高いです。</p>
<p>次に、<code>pg_blocking_pids()</code>を使って、そのセッションを待たせているPIDを確認します。待っているSQL だけを見ても、原因は分かりません。重要なのは、待っている（ウェイター）側と、待たせている（ブロッカー）側を分けて見ることです。</p>
<p>待たせている（ブロッカー）側のPIDが分かったら、もう一度<br />
<code>pg_stat_activity</code><br />
を確認します。特に、<code>state</code>、<code>xact_start</code>、<code>state_change</code>、<code>application_name</code>、<code>client_addr</code>、<code>query</code> を見ます。<code>state = 'idle in transaction'</code>で、<code>xact_start</code> が古い場合は、トランザクションを開いたまま放置している可能性があります。ただし、すぐにセッションを終了すればよいとは限りません。まず、どのアプリケーション、どの接続元、どの処理がトランザクションを開いたままにしているのかを確認します。</p>
<h2>再発を減らす設計</h2>
<p>ロック待ちそのものは、PostgreSQLの異常ではありません。同じ行を同時に更新しようとすれば、待つことがあります。</p>
<p>問題になるのは、待たせているトランザクションが長く残り、他の処理を止め続けることです。</p>
<p>ここでは、再発を減らすための基本的な考え方を整理します。</p>
<h3>トランザクションを短くする</h3>
<p>更新や明示的なロックを取得したあとは、できるだけ早く<code>COMMIT</code>または<code>ROLLBACK</code>します。トランザクション中に外部API 呼び出し、ユーザー入力待ち、重いファイル処理などを入れると、ロックを持ったまま待ち時間が伸びます。また、例外が発生した場合は、必ず <code>ROLLBACK</code>します。</p>
<h3>更新順序をそろえる</h3>
<p>複数行を更新する処理では、更新順序をそろえます。ある処理は<code>id = 1</code>のあとに<code>id = 2</code>を更新し、別の処理は <code>id = 2</code>のあとに<code>id = 1</code>を更新すると、デッドロックが起きやすくなります。順序を決められるなら、常に同じ順序で更新します。</p>
<h3>lock_timeoutを検討する</h3>
<p>長時間待たせたくない処理では、<code>lock_timeout</code>を検討します。</p>
<pre><code>SET lock_timeout = '3s';
</code></pre>
<p>これは、ロックを取得できない状態が指定時間を超えたら、そのSQL をエラーにする設定です。ただし、エラーになった場合にアプリケーション側でどう扱うかを決めておく必要があります。</p>
<h3>log_lock_waitsを確認する</h3>
<p>本番環境では、<code>log_lock_waits</code>も確認対象になります。<code>log_lock_waits</code>を有効にすると、<code>deadlock_timeout</code> を超えたロック待ちをログに出せます。常に<code>pg_stat_activity</code>を手動で見続けるのではなく、ログから、どのSQL がいつ、どの程度ロック待ちしたのかを後から確認できます。</p>
<h3>アプリケーションで再試行を考える</h3>
<p>デッドロックやロックタイムアウトで失敗した場合、失敗したSQL だけを途中から再実行するのは危険です。基本は、トランザクション全体を最初からやり直します。ただし、無制限に再試行し続けるのではなく、再試行回数には上限を設けます。</p>
<h3>UPDATEのWHEREに条件を入れる</h3>
<p>並行更新で条件が変わる処理では、事前の<code>SELECT</code>結果だけに頼らないようにします。たとえば、残高が足りる場合だけ引き落とすなら、条件を <code>UPDATE</code>の<code>WHERE</code>に入れます。</p>
<pre><code>BEGIN;
UPDATE accounts
SET balance = balance - 500
WHERE id = 1
  AND balance &gt;= 500;
COMMIT;
</code></pre>
<p>以上、<code>UPDATE</code>が返ってこない状況を、同じ行への更新、ロック待ち、待たせているトランザクション、通常の <code>SELECT</code>の見え方に分けて確認しました。</p>
<p>ロック待ちそのものは、PostgreSQL の異常ではありません。同じデータを同時に矛盾なく更新するために必要な動きです。問題になるのは、ロックを持ったトランザクションが長く残り、他の処理を止め続けることです。</p>
<p><code>UPDATE</code>が返ってこないときは、待っているSQLだけを見るのではなく、PostgreSQLの中で何を待っているのかを確認します。そのうえで、<code>pg_blocking_pids()</code> を使い、待たせている相手を探します。</p>
<p>待っている側と、待たせている側を分けて見る。この見方を持っておくと、ロック待ちを原因の一つとして落ち着いて切り分けられます。</p>
<div>
<a href="https://www.sraoss.co.jp/prod_serv/support/pgsql-mainte/?utm_source=sraoss-techblog&utm_medium=referral&utm_campaign=under-article-pgsql" rel="noopener" style="color:initial;" target="_blank" class="no-ext"></p>
<div style="background-color:#DAEFF6; padding:20px; border-radius:8px; text-align:center;">
SRA OSSでは、PostgreSQL/Pgpool-II のサポートを提供しております。<br />
詳しくは<strong style="color:#2581c4;">弊社ホームページ</strong>をご覧ください。
</div>
<p></a>
</div>

]]></content:encoded>
					
		
		
			</item>
	</channel>
</rss>
