CodeGym /コース /C# SELF /デッドロックの予防と解消

デッドロックの予防と解消

C# SELF
レベル 57, レッスン 2
使用可能

1. コフマンの古典的条件

1971年に計算機科学者の エドワード・コフマン (Edward G. Coffman Jr.) が、deadlock が起こるために必要な4つの条件を説明しました。これらのルールはマルチスレッドの面接や講義で「基本」とされます。丸暗記するだけでなく、なぜ必要かを理解しておくと役に立ちます:

  1. 相互排他 (Mutual Exclusion): 少なくとも一つのリソースは同時に一つのスレッドしか保持できない。
  2. 保持と待機 (Hold and Wait): あるリソースを保持しているスレッドが他のリソースを待っている可能性がある。
  3. 強制奪取不可 (No Preemption): リソースは強制的にスレッドから取り上げられない — スレッド自身が解放するしかない。
  4. 循環待ち (Circular Wait): 各スレッドが次のスレッドが保持するリソースを待つようなサークルが存在する。

これらすべての条件が満たされると、deadlock が起きうる。どれか一つでも破れば、相互ブロックの可能性は消えます。

素早い意思決定フロー

flowchart TD
    A[複数のリソースをロックする必要がある?] -- いいえ --> B[標準の lock]
    A -- はい --> C[常に同じ順序で取れるか?]
    C -- はい --> D[常に同じ順序で取得する]
    C -- いいえ --> E[ネストした lock を避ける]
    D --> F[ロック下の時間を最小化する]
    E --> F
    B --> F
    F --> G{それでも不安?}
    G -- はい --> H[タイムアウトとリトライを追加]
    G -- いいえ --> I[安心してOK!]

2. デッドロック予防の主要戦略

deadlock はマルチスレッド世界の一部なので、共存する方法を学ぶのが仕事です。シンプルなものから巧妙なものまで、いくつかの戦略が役立ちます。

常に同じ順序でリソースをロックする

要点はシンプル:全スレッドが常にリソースを同じ順序で取得すれば、循環待ちは発生しません。この手法は ordered locking(順序化ロック)と呼ばれます。

例

まず危険なコード:


// スレッド1
lock (resA)
{
    lock (resB)
    {
        // ...
    }
}

// スレッド2
lock (resB)
{
    lock (resA)
    {
        // ...
    }
}

ここでは deadlock が起こりうる:スレッド1は resA を取り resB を待ち、スレッド2はその逆。両方がハングして解放されません。

正しいコード:


// 常に: まず resA、次に resB(逆はしない)
lock (resA)
{
    lock (resB)
    {
        // ...
    }
}

これで順序が統一され、deadlock は発生しません。リソースがいくつあっても、すべてのスレッドが同じ順序でロックを取ることが重要です。

典型的なミス:コードのどこかに順序が破られる箇所があると、deadlock のリスクが戻ります。注意して設計しましょう。

複数リソースの同時ロックを避ける

最も簡単なのは、二つ以上のリソースを同時にロックしないこと。ネストしたロックが多いほどハマりやすくなります。必要ならデータを一時変数にコピーしてロックを解放してから他を操作するなど工夫しましょう。

ロック取得にタイムアウトを使う

どうしても複数ロックが必要な場合はタイムアウトが助けになります。普通の lock の代わりに、ロックを「試す」メソッドを使い、取れなければ巻き戻す、という考え方です。例えば Monitor.TryEnter を使います。


object resourceA = new object();
object resourceB = new object();

bool successA = false, successB = false;
try
{
    // 最大2秒で両方のロックを試す
    successA = Monitor.TryEnter(resourceA, TimeSpan.FromSeconds(2));
    if (!successA) return; // 取得できずに抜ける

    successB = Monitor.TryEnter(resourceB, TimeSpan.FromSeconds(2));
    if (!successB) return;

    // クリティカルセクション
}
finally
{
    if (successB) Monitor.Exit(resourceB);
    if (successA) Monitor.Exit(resourceA);
}

もし2秒で2つ目のロックが取れなければ、最初のロックを解放して抜けます。結果として deadlock にはならず、一部スレッドの試行がロールバックされます。

ロック内のコード量を最小化する

ロック下のコードが短ければ短いほど、他のスレッドの待ち時間は減ります。重い計算、ネットワーク呼び出し、ディスク操作はクリティカルセクションの外で行うべきです。ロックを取ったら共有状態を素早く変更して解放しましょう。

状態を分離する — 共有リソースを避ける

時にはロックと戦うより、共有状態を避ける方が簡単です:

  • イミュータブルなオブジェクトを使う(immutable)。
  • グローバルの代わりにコピーやローカル変数を使う。
  • メッセージパッシングでデータを渡す(Actor Model、メッセージキュー)。
  • ConcurrentDictionary、ConcurrentQueue など、System.Collections.Concurrent のスレッドセーフなコレクションを使う。

3. 既に発生した Deadlock の解決

手動でプロセスを殺して再起動(最終手段)

最も単純な方法は、ハングしているプロセスを全部終了することですが、データ損失のリスクがあります。最終手段としてのみ考えてください。

動作中の Deadlock 検出

一部のシステムは deadlock を自動検出できます。スレッドが長時間ロックを取れない場合にログを残したり、監視に通知して復旧を始める仕組みを入れられます。


if (!Monitor.TryEnter(resource, TimeSpan.FromSeconds(10)))
{
    Console.WriteLine("どうやら deadlock に陥ったか、誰かがロックを長時間保持しています!");
    // 復旧を開始する、ダンプを取る、ユーザーに通知する、など
}

分散システムでは、待ちグラフを解析してハングしたトランザクションを強制的に解放するデテクタを使います。

自動ロールバックとリトライ

便利なパターンは「諦めて再試行する」こと:一定時間内に全てのロックが取れなければロールバックし、少し待って(多くの場合ランダムな遅延で衝突を散らす)再試行します。


for (int attempt = 0; attempt < 3; attempt++)
{
    bool gotRes1 = Monitor.TryEnter(res1, TimeSpan.FromSeconds(2));
    bool gotRes2 = false;
    try
    {
        if (gotRes1)
        {
            gotRes2 = Monitor.TryEnter(res2, TimeSpan.FromSeconds(2));
            if (gotRes2)
            {
                // クリティカルセクション
                break;
            }
        }
    }
    finally
    {
        if (gotRes2) Monitor.Exit(res2);
        if (gotRes1) Monitor.Exit(res1);
    }

    // 失敗したら待って再試行
    Thread.Sleep(500 + new Random().Next(500));
}

4. ベストプラクティスと推奨事項

  • ロック取得の順序を解析する。 エントリポイントを集めて順序をチェックする。
  • 可能なら System.Collections.Concurrent のコレクションを使う。
  • コード解析ツールを使う。 Rider や Visual Studio はネストしたロックを見つけるのに役立つ。
  • ロック取得に時間がかかるケースをログに残す。
  • マルチスレッドコンポーネントに対してストレステストを行う。
  • ロック順序のルールをドキュメント化する。 コメントが順序違反を防ぐ助けになる。

5. 実用的な例

例: データベース

RDBMS では deadlock がよく起きます:2つのトランザクションが同じテーブルを異なる順序で更新する(A→B と B→A)。多くのDBはこうした状況を検出して、どちらか一方のトランザクションを「殺す(ロールバック)」します。

例: 非同期メソッド

.NET では async とロックを混ぜると相互ブロックを招くことがあります:await がロックを保持したままスレッドを解放し、別スレッドが同じリソースを待つ、など。クリティカルセクションの境界を設計し、待機をロック内で行わないようにしましょう。

6. ロック操作でよくあるミス

誤り #1: 文字列をロックすること。
lock (myString) — これは良くない。 .NET の文字列はインターンされるため、実質的にグローバルな文字列テーブルをロックすることになる。

誤り #2: オブジェクトの取得順序が異なること。
プログラムの異なる箇所でロックの順序がバラバラだと、deadlock の確率が急上昇します。

誤り #3: ロックを長時間保持すること。
ロックを必要以上に長く保持したり、クリティカルセクション内で外部メソッドを呼ぶのは、ハングや相互ブロックを招く典型的なミスです。

2
タスク
C# SELF, レベル 57, レッスン 2
ロック未解除
デッドロック検出時の自動ロールバックの実装
デッドロック検出時の自動ロールバックの実装
コメント
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION