CodeGym /コース /C# SELF /ロック: lock と クラス Monitor

ロック: lock と クラス Monitor

C# SELF
レベル 56, レッスン 1
使用可能

1. はじめに

スレッドを扱うときによくある状況を見てみましょう。とてもシンプルなアプリケーションで共有の成功カウンターがあるとします。

int counter = 0;

void IncrementCounter()
{
    for (int i = 0; i < 100_000; i++)
    {
        counter++; // アトミックではない!
    }
}

// 二つのスレッドを起動:
Thread t1 = new Thread(IncrementCounter);
Thread t2 = new Thread(IncrementCounter);

t1.Start();
t2.Start();

t1.Join();
t2.Join();

Console.WriteLine($"Counter: {counter}");

このコードを何度か実行してみてください。ほとんどの場合、200_000 にはなりません!なぜでしょう?二つのスレッドが常に互いに干渉して、時々両方が同時に変数を読み取り、増やして、同じ結果を書き戻してしまいます。結果として一部のインクリメントが「失われる」んです。

これがいわゆるレースコンディション(Race Condition)です。順番のルールを守らないと、スレッド同士が文字通りデータを奪い合います。

クリティカルセクション:それは何?

クリティカルセクション は、一度に一つのスレッドだけが実行すべきコード領域です。キッチンの例で言うと:蛇口の前に二人で並んで顔を洗おうとしたら、シャツや歯磨き粉が散らかりますよね。お風呂は一人ずつ入ると約束しましょう!

この例ではクリティカルセクションは行 counter++ です。

2. キーワード lock

C# にはクリティカルセクションを作る簡潔で安全な方法があります — キーワード lock。これが同期プリミティブの複雑さを隠してくれて、保護されたブロックに一度に一つのスレッドだけが入るようにしてくれます。

lock の使い方

構文:

lock (lockerObject)
{
    // 一度に一つのスレッドだけが実行できるコード
}

lockerObject はプログラムのライフタイムを通して存在する任意のオブジェクトです。普通はこんな感じにします:

private static object locker = new object();

注意:この目的で文字列、数値、または誰かが偶然アクセスできるオブジェクトを使わないでください! 常に他で絶対に使われない private なオブジェクトを使いましょう。

サンプルを修正する

private static object locker = new object();
int counter = 0;

void IncrementCounter()
{
    for (int i = 0; i < 100_000; i++)
    {
        lock (locker)
        {
            counter++; // これでアトミックになった!
        }
    }
}

これで二つでも十個でもスレッドが順番にこのコードに入ります。結果は完璧な 200_000。ネコたちも満足です!

3. lock は内部でどう動く?クラス Monitor

内部的にキーワード lock はクラス System.Threading.Monitor を使っています。これは特別なパスを持つ秘書のようなもので、許可された人だけを通します。

等価な(ただしより「剥き出しな」)構文:

Monitor.Enter(locker);
try
{
    // クリティカルセクション
}
finally
{
    Monitor.Exit(locker);
}

重要な違いは、自分で必ず Monitor.Exit を呼ぶことを保証しなければならない点です。普通はそのために try...finally を使います。もし Exit() の呼び出しを忘れると、スレッドは永久に「中に」残り、他のスレッドは永遠に待つことになります — 古い Windows がアップデート中に固まるような状態です。

表: lock vs 手動の Monitor

方法 エラー耐性 書きやすさ 柔軟性
lock(obj)
あり あり なし
Monitor
try/finally があれば いいえ あり

99% のケースでは lock を使ってください。手動の Monitor が必要になるのは、例えばタイムアウト付きのロックを実装したいときなど、最大の柔軟性が必要な場合だけです。

4. lock に渡す引数:何が許されて何がダメか?

初心者がよくやるミス:ロックに 文字列 や他の「見える」オブジェクトを使ってしまうこと。例えば:

lock ("mylock") { /*...*/ } // すごくダメ!

問題は文字列がインターンされて(アプリ全体で一意になって)しまうことです。他のライブラリと簡単に衝突してしまい、結果としてプログラムがデッドになってしまう可能性があります。必ず private なオブジェクトを使ってください:

private readonly object myLock = new object();

lock (myLock)
{
    // myLock を知っているのはあなただけ
}

5. lock:コンソール出力の例

練習しましょう!二つのスレッドが文字列を出力しますが、コンソールへのアクセスも同期して文字が混ざらないようにします。

private static object consoleLock = new object();

void PrintMessages(string name)
{
    for (int i = 0; i < 5; i++)
    {
        lock (consoleLock)
        {
            Console.WriteLine($"{name}: メッセージ {i + 1}");
            Thread.Sleep(50); // 処理をシミュレート
        }
    }
}

Thread t1 = new Thread(() => PrintMessages("スレッド 1"));
Thread t2 = new Thread(() => PrintMessages("スレッド 2"));

t1.Start();
t2.Start();

t1.Join();
t2.Join();

結果:行はきちんと順番に出力され、混ざり合うことはありません。ログ出力で「文字化け」を防ぐためにこのやり方はよく使われます。

6. 役立つ細かい点

手動でのロック管理:上級者向け Monitor

標準の lock だけでは足りない(例えば無限に待ちたくない場合)ときは、Monitor.TryEnter を使えます。

if (Monitor.TryEnter(locker, 100)) // 100 ミリ秒待つ
{
    try
    {
        // クリティカルセクション
    }
    finally
    {
        Monitor.Exit(locker);
    }
}
else
{
    Console.WriteLine("100ミリ秒以内にロックを取得できませんでした");
}

ロックが取れないとプログラムを「ハング」させたくないときに便利です。例えばユーザーにメッセージを出したり、共有リソースが使われている間に別の有用なことをしたりできます。

視覚化:ロックがどう動くか(図)

flowchart LR
    A[スレッド1: クリティカルセクションに入りたい]
    B[スレッド2: クリティカルセクションに入りたい]
    C[locker は空いている]
    D[スレッド1 が lock 内で実行中]
    E[スレッド2 は待機]
    F[スレッド1 が lock から出た]
    G[スレッド2 がアクセスを得る]
    
    A -- locker をチェック --> C
    C -- locker は空いている --> D
    B -- locker をチェック --> D
    D -- lock は占有中 --> E
    D -- 作業完了 --> F
    F -- locker を解放 --> G
    E -- locker が空いた --> G

ロックとパフォーマンス

ロックはシンプルです:一度に一つのスレッドだけ が中括弧内のコードを実行できます。データ整合性には最適ですが…待機中のスレッドが多くなるほど全体が遅くなります。だから同期は万能薬ではありません:クリティカルセクションはできるだけ小さくするようにしましょう。

ライフハック: クリティカルセクションの処理がミリ秒未満なら問題なし。もしそこに長い計算や入出力、ネットワークやファイル操作が含まれるなら、ブロック外に分離するのが良いです。まず読み取りや計算をしてから、共有値の更新だけを素早くロック内で行いましょう。

面接や実務での話

スレッドを使う真面目なプログラムでは、面接で必ず聞かれます:「二つのスレッドが同じ変数にアクセスする場合どうする?」 ロックを使ったコードを示せれば、あなたの履歴書が HR のブラックホールに消えることはありません。

実運用では高負荷システムでさらに進んだ同期手段を使うこともありますが、シンプルなケースでは lock と Monitor がゴールドスタンダードであり続けます。

7. ロック利用の注意点と典型的なミス

最も多いミスは、同じロックオブジェクトを使い忘れることです。例えば:

void Foo() { lock (a) { ... } }
void Bar() { lock (b) { ... } }

もし両方のメソッドが同じ変数を操作しているのに、オブジェクト a と b が別物なら、本当の保護にはなりません — スレッドは同時にその変数を操作してしまいます!

結論: 同じデータを守るなら必ず同じオブジェクトを使ってください。

別のケースは「広すぎる」ロックの使用です。例えば普通のクラス内で lock (this) を使うのは危険です。外部の誰かが同じオブジェクトをロックに使っているかもしれず、それがデッドロックや他のやっかいなバグにつながります。

最後に:lock の中で長時間かかる外部操作(ファイル操作、ネットワーク)は絶対に行わないでください。そうすると他のスレッドが長時間ブロックされ、パフォーマンスが落ちます。クリティカルセクションは「並列にできないこと」だけに限定しましょう!

2
タスク
C# SELF, レベル 56, レッスン 1
ロック未解除
lock を使った超シンプルな同期
lock を使った超シンプルな同期
コメント
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION