CodeGym /コース /C# SELF /オプティマイゼーションと ReaderWriterLockSlim

オプティマイゼーションと ReaderWriterLockSlim

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

1. なぜ通常の lock では不十分なことがあるのか?

考えてみましょう:共有リソースがあって—例えば、マルチスレッドアプリケーションのどこかに置いてあるクライアントのリストです。大部分の時間はそのリストを読むだけです—例えば、UIでユーザーにデータを見せたり、レポートを作ったり、フィルタやソートをしたり。新しいクライアントを追加したり古いのを削除するのは稀です。

おなじみの lock を使うと、データを読みたいスレッドは別のスレッドが読み書きしているのを待たなければなりません。しかも読みが全操作の約99%を占めるならどうでしょう?読者スレッド全員を無駄にブロックしてしまい、並列に動けるはずの処理を潰してしまいます。

ここで役に立つのが特殊なロックタイプ、Reader-Writer Lock(リーダー・ライター・ロック)です。キーとなる考え方は:複数のスレッドが同時に読み取れるが、誰かが変更したいときは排他アクセスを取り、読み取り側をブロックする、というものです。

2. 理論:ReaderWriterLockSlim とは何か

クラスについて簡単に

  • ReaderWriterLock — 古くて遅く、デッドロックを引き起こすことがある。もし .NET Framework 2.0 をサポートする必要があるなら使うが、それ以外では避けるべき。
  • ReaderWriterLockSlim — 高速で現代的な代替(Slimは「スリム」「軽量」の意味)。このクラスは読み取り/書き込みの競合が頻繁に起きるシナリオに最適化されていて、スレッドが多く読み取りが書き込みよりずっと多いアプリケーションで推奨されます。

動作原理

ReaderWriterLockSlim は3つのロックモードを実装しています:

  • Read Lock(読み取りロック):複数のスレッドが同時に読み取れる。
  • Write Lock(書き込みロック):単一のスレッドだけがデータを変更でき、他は読み取れない。
  • Upgradeable Read Lock(アップグレード可能な読み取りロック):同時にこのロックを持てるのは1つのスレッドだけで、そのスレッドは読み取りを行い、必要ならwrite lockに「昇格」できる。

ロックの互換性図

リーダースレッド ライタースレッド Upgradeable Read Lock を持つスレッド
リーダー ✅ ⛔ ✅/⛔
ライター ⛔ ⛔ ⛔
Upgradeable Read ✅* ⛔ ⛔

✅ — 許可されている

⛔ — ブロックされる

* — upgradeable read lock が write に「昇格」していない場合に限る

いつ使うべきか(と使うべきでない場合)

推奨:

  • 同時に多数のスレッドがいて、主に共有データ(参照データ、キャッシュ、設定)を読む場合。
  • 書き込みは稀(例えば、1秒/分/時間に一度程度)である場合。
  • 読み取りのパフォーマンスを最大化したいとき、スレッドを妨げたくない場合。

推奨しない:

  • 読み書きの比率がほぼ同じ(その場合は通常の lock の方が良い)。
  • データが頻繁に変わる(メリットが小さい)。

3. 実践での ReaderWriterLockSlim の使い方

学習用アプリケーションを拡張してみましょう!以前はシンプルなクライアントディレクトリを作って、コレクションへのマルチスレッドアクセスを試しました。ここでは少し複雑にして、複数のスレッドがアクセスするクライアントリスト(例えば、あるスレッドが全クライアントに通知を送信し、別のスレッドが新しいクライアントを追加する)を考えます。

まずクライアントコレクションを定義します:


// クライアントクラス — 前の講義で見たおなじみの主人公
public class Client
{
    public int Id { get; set; }
    public string Name { get; set; }
}

次に ReaderWriterLockSlim を使ってスレッドセーフなラッパーを作ります:

using System;
using System.Collections.Generic;
using System.Threading;

public class ClientDirectory
{
    private readonly List<Client> _clients = new List<Client>();
    // 読み書き用のスリムロック
    private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();

    // クライアントの追加(write lock)
    public void AddClient(Client client)
    {
        _lock.EnterWriteLock(); // クライアントを追加できるのは1スレッドだけ
        try
        {
            _clients.Add(client);
            Console.WriteLine($"[スレッド {Thread.CurrentThread.ManagedThreadId}] クライアントを追加しました {client.Name}");
        }
        finally
        {
            _lock.ExitWriteLock();
        }
    }

    // クライアントリストのコピーを取得(read lock)
    public List<Client> GetClients()
    {
        _lock.EnterReadLock(); // 複数のスレッドが同時に読める
        try
        {
            // 誰かがオリジナルを誤って変更しないようにコピーを返す
            return new List<Client>(_clients);
        }
        finally
        {
            _lock.ExitReadLock();
        }
    }
}

4. マルチスレッドの読み取りと定期的な書き込み

例えば、5つのスレッドが定期的に全クライアントを読み(「レポートを作る」や単に誰がいるか確認する)、別のスレッドが時々新しいクライアントを追加する、という状況を考えます。

using System.Threading;

class Program
{
    static void Main()
    {
        var directory = new ClientDirectory();

        // クライアントを追加するスレッド
        var writerThread = new Thread(() =>
        {
            for (int i = 1; i <= 5; i++)
            {
                directory.AddClient(new Client { Id = i, Name = $"クライアント {i}" });
                Thread.Sleep(700); // 長めの操作を模擬
            }
        });

        // 複数のリーダー
        for (int j = 0; j < 5; j++)
        {
            int readerId = j + 1;
            new Thread(() =>
            {
                for (int k = 0; k < 10; k++)
                {
                    var clients = directory.GetClients();
                    Console.WriteLine($"[リーダー {readerId}][スレッド {Thread.CurrentThread.ManagedThreadId}] クライアント数: {clients.Count}");
                    Thread.Sleep(200); // 書き込みより頻繁に読む
                }
            }).Start();
        }

        writerThread.Start();
        writerThread.Join();

        // リーダーが終わる時間を少し与える:
        Thread.Sleep(3000);
    }
}

ほとんどの場合、複数のスレッドが同時にクライアントリストを読むことができます(互いに待つ必要はありません)。しかし、あるスレッドがクライアントを追加する際には、他のスレッドは書き込みが終わるまで待たなければなりません。これにより、読み取り側の過剰なブロッキングを避けつつ多くのリクエストをさばけます。

5. アップグレード可能なロック:UpgradeableReadLock

状況によっては、スレッドがまずデータを読み、条件に応じてたまに変更したいことがあります。一見、read lock を取って条件をチェックし、read lock を解放してから write lock を取れば良さそうに思えます。しかしその「間」に別のスレッドがデータを変えてしまうかもしれません。そこで役立つのがアップグレード可能なロックです。

使い方は簡単です:

public bool AddClientIfNotExists(string name)
{
    _lock.EnterUpgradeableReadLock(); // このロックを持てるのは1スレッドだけ
    try
    {
        bool exists = _clients.Exists(c => c.Name == name);
        if (!exists)
        {
            _lock.EnterWriteLock(); // write lock に昇格
            try
            {
                _clients.Add(new Client { Name = name });
                return true;
            }
            finally
            {
                _lock.ExitWriteLock();
            }
        }
        return false;
    }
    finally
    {
        _lock.ExitUpgradeableReadLock();
    }
}

最初は読み取りを行い、変更が必要ならばロックのレベルを上げて(他のスレッドにリストを渡さずに)変更します。

6. 便利な注意点

比較:ReaderWriterLockSlim と lock

lock
ReaderWriterLockSlim
同時読み取り いいえ はい
同時書き込み いいえ いいえ
アップグレード可能な読み取りのサポート いいえ はい(EnterUpgradeableReadLock)
速度 とても速い 読み取りが頻繁な場合はより速い
メモリ 最小限 少し多め
簡単さ 簡単 やや複雑で注意点がある

現実のプロジェクトでの見え方

巨大なテーブルやキャッシュを持ち、数百のスレッドが読み取りを行い、更新は稀にしか起きないような大規模アプリケーションでは、ReaderWriterLockSlim を使うことで読み取りでのボトルネックを避けられます。例:

  • マイクロサービスで共有される設定キャッシュ。
  • 金融計算向けの参照データストア。
  • メッセージルーティング用の内部キャッシュ。

強調したいのは—特にマルチスレッドをこれから学ぶ人にとっては、普通の lock の方が簡単で安全な場合が多いということです。ReaderWriterLockSlim は、本当に同時読み取りが多いという要件があるケースで有効なツールです。

視覚化:アクセスの図

flowchart TD
    A[リーダースレッド 1] --Read--> D[ReaderWriterLockSlim]
    B[リーダースレッド 2] --Read--> D
    C[ライタースレッド] --Write--> D
    D --Read 許可--> E[共有コレクションの読み取り]
    D --Write は読み取り/書き込みをブロック--> F[共有コレクションの書き込み]

読み取りだけの間は全員にアクセスが開かれ、書き込みが来たときは書き込みが終わるまで全員が待ちます。

7. ReaderWriterLockSlim:細かい点と典型的なミス

Lock Recursion(ロックの再帰): デフォルトでは ReaderWriterLockSlim は同じスレッドが同じ種類のロックを再取得することを許しません。つまり、スレッドが既に read lock を保持していて再度取得しようとすると例外が投げられます。write lock も同様です。ただし、UpgradeableReadLock は内部から write lock に昇格できます。

順序を間違えないこと: EnterUpgradeableReadLock() を取得して→その内部で EnterWriteLock() を呼ぶ、という順が必要です。逆はダメです!

例外時の扱い: もしロックを解放し忘れると(例えば ExitWriteLock() を呼ばなかった場合)、他のスレッドは永遠に待つことになります。だから常に try { ... } finally { ... } を使ってください。

長時間保持しない: ロック内で長時間の IO 操作を行わないでください。スレッドがロックを長く持つほど、他のスレッドの遅延が大きくなります。できるだけ早くロックを解放するようにします。

複雑さを評価する: 小さな操作を保護するのに ReaderWriterLockSlim を使うべきではありません。普通の lock の方がシンプルで速いことが多いです。

2
タスク
C# SELF, レベル 56, レッスン 4
ロック未解除
ReaderWriterLockSlimを使った読み取りの実装
ReaderWriterLockSlimを使った読み取りの実装
1
アンケート/クイズ
スレッド同期、レベル 56、レッスン 4
使用不可
スレッド同期
共有リソースの問題
コメント
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION