MENU
  1. ホーム
  2. Ruby
  3. RubyのConditionVariableで複雑なスレッド同期処理を実装する方法

RubyのConditionVariableで複雑なスレッド同期処理を実装する方法

Ruby

Rubyの並列処理において、スレッド間での正確な同期は複雑なタスクとなります。マルチスレッドのプログラムでは、スレッド間でデータを共有したり、処理の順序を管理する必要がありますが、競合状態やデッドロックといった問題が発生しやすくなります。このような問題を回避し、安全かつ効率的にスレッドを制御するための一つの方法がConditionVariableの利用です。

ConditionVariableは、ある条件が満たされるまでスレッドを待機させ、条件が整った時点で待機しているスレッドに通知を送る機能を提供します。本記事では、ConditionVariableの仕組みや、具体的な実装方法、そして複数スレッドの同期における活用法について詳しく解説します。これにより、Rubyでの複雑なスレッド同期処理を効果的に実現するための基礎を身に付けることができます。

目次

`ConditionVariable`の基本と用途

ConditionVariableは、スレッド間での同期処理を行うためのクラスで、特定の条件が満たされるまでスレッドを待機させたり、条件が整った際に他のスレッドへ通知を送る機能を提供します。これにより、複数のスレッドが協調して動作することが可能になります。

通常、スレッドが並行して実行される環境では、リソースの共有や処理の順序を制御する必要がありますが、単純なロック機構（Mutexなど）だけでは不十分な場合があります。例えば、あるスレッドがリソースの準備を完了してから他のスレッドがそのリソースを使用する場合や、複数のスレッドが条件に基づいて順次実行される必要がある場合です。このようなシナリオで、ConditionVariableは非常に有効に機能します。

RubyのConditionVariableは、主に以下のような場面で利用されます。

用途

  1. スレッド待機と通知：条件が整うまでスレッドを待機させ、条件が満たされたタイミングで他のスレッドへ通知します。
  2. 複数スレッドの協調制御：複数のスレッドが連携しながら同じリソースを操作したり、異なるタイミングで条件を満たすときに同期を取ります。
  3. 生産者-消費者モデルの実装：リソースの生産と消費のタイミングが異なる場合に、ConditionVariableを利用して適切なタイミングでスレッドを実行します。

ConditionVariableを活用することで、より高度で効率的なスレッド間の制御が可能となり、安全で協調的な並列処理が実現できます。

スレッドと同期処理の基礎

スレッドは、プログラムの中で並行して実行される軽量な処理単位です。Rubyでは、Threadクラスを使用して複数のスレッドを生成し、並列処理を行うことができます。これにより、複数のタスクを同時に実行できるため、効率的なプログラムの実行が可能になります。

しかし、スレッドが同時に動作することで、同じリソースやデータにアクセスしようとする際に、競合状態（レースコンディション）やデータの整合性が失われるリスクが生じます。例えば、あるスレッドがデータを書き換えている途中で、他のスレッドが同じデータにアクセスした場合、予期せぬ結果やエラーが発生する可能性があります。こうした問題を防ぐために、スレッド間の同期処理が重要です。

同期処理の必要性

同期処理は、複数のスレッドが特定の順序で動作したり、同じリソースに対して整合性のある操作を行うために必要な技術です。同期処理を適切に行うことで、次のようなメリットがあります。

  1. データの整合性：複数のスレッドが同じデータにアクセスする場合、同期を取ることでデータの一貫性を保ちます。
  2. 競合状態の防止：複数のスレッドが同時にリソースにアクセスする際の競合状態を防ぎます。
  3. スレッド間の処理順序の制御：特定のスレッドが別のスレッドの処理完了を待つといった順序制御が可能になります。

Rubyにおける同期処理の基本ツール

Rubyでは、同期処理を行うためにいくつかのツールが提供されています。

  • Mutex（相互排他ロック）：複数のスレッドが同時に同じリソースにアクセスしないように、排他ロックを提供します。
  • Queue（キュー）：スレッド間でデータを安全にやり取りするためのキューで、スレッドセーフなデータ構造です。
  • ConditionVariable：特定の条件が満たされるまでスレッドを待機させ、条件が整った際に通知を送ることでスレッド間の同期を取ります。

ConditionVariableは、特に複雑なスレッド間の同期処理で効果を発揮し、特定の条件が満たされるまで待機したり、特定のタイミングで他のスレッドを動かすための制御が可能です。

`ConditionVariable`とMutexの連携

ConditionVariableを効果的に利用するには、Mutex（相互排他ロック）と組み合わせることが必要です。Mutexは複数のスレッドが同時に同じリソースにアクセスするのを防ぐために使用されますが、ConditionVariableはその上で、条件に基づいた同期処理を実現するためのクラスです。

通常、ConditionVariableを使うときには、Mutexでリソースへのアクセスを保護し、ある条件が満たされるまでスレッドを待機させるか、条件が整ったら別のスレッドを動かす、といった制御を行います。このようにConditionVariableとMutexを組み合わせることで、より柔軟で精密な同期が可能になります。

Mutexとの基本的な連携方法

  1. Mutexでリソースをロックする
    Mutexを使用して、共有リソースへのアクセスを排他的に制御します。ロックすることで、他のスレッドがリソースにアクセスできないようにします。
  2. ConditionVariableの待機
    ConditionVariableのwaitメソッドを使用して、特定の条件が満たされるまでスレッドを待機させます。このとき、Mutexのロックは一時的に解放されるため、他のスレッドがリソースにアクセスできます。
  3. 条件が整ったら通知を送信
    他のスレッドが条件を満たしたタイミングで、ConditionVariableのsignalまたはbroadcastメソッドを使用して待機中のスレッドに通知を送ります。これにより、待機していたスレッドが処理を再開します。

基本的なコード例

以下は、MutexとConditionVariableを使ってスレッド間の同期を取る基本的なコード例です。

require 'thread'

mutex = Mutex.new
condition = ConditionVariable.new
shared_resource = []

producer = Thread.new do
  mutex.synchronize do
    shared_resource << "data"
    condition.signal  # データが追加されたら通知を送信
  end
end

consumer = Thread.new do
  mutex.synchronize do
    condition.wait(mutex) if shared_resource.empty?  # リソースが空なら待機
    puts "Consumed: #{shared_resource.pop}"
  end
end

[producer, consumer].each(&:join)

この例では、producerスレッドがshared_resourceにデータを追加し、condition.signalで待機中のconsumerスレッドに通知を送ります。consumerスレッドは、データが追加されるまで待機し、通知を受け取ったらデータを消費します。このように、MutexとConditionVariableを連携させることで、スレッド間の協調動作をスムーズに実現できます。

この手法により、複雑な並行処理やリソースの共有を安全かつ効率的に行うことが可能となります。

`ConditionVariable`のメソッド解説

RubyのConditionVariableには、スレッド間の同期を制御するための重要なメソッドがいくつか用意されています。これらのメソッドを理解し、適切に使い分けることで、より効果的なスレッド同期処理が可能となります。以下では、ConditionVariableの代表的なメソッドであるwait、signal、broadcastについて詳しく説明します。

1. `wait`メソッド

waitメソッドは、指定されたMutexオブジェクトとともに使用されます。このメソッドは、Mutexがロックされた状態で呼び出される必要があり、呼び出し元のスレッドを指定された条件が満たされるまで待機状態にします。waitメソッドが呼ばれると、一時的にMutexのロックが解放され、他のスレッドがリソースにアクセスできるようになります。待機状態が解除されると、再度Mutexがロックされ、処理が続行されます。

mutex = Mutex.new
condition = ConditionVariable.new

mutex.synchronize do
  condition.wait(mutex)  # 指定された条件が満たされるまで待機
  # 条件が満たされた後の処理
end

2. `signal`メソッド

signalメソッドは、待機中のスレッドのうち一つを起こして処理を再開させます。signalは通常、あるスレッドが条件を満たした際に、その条件を待機していたスレッドに通知を送るために使用されます。例えば、生産者と消費者の関係で、あるスレッドがデータを用意できたことを通知する際に役立ちます。

mutex.synchronize do
  # 条件が満たされた場合に通知を送る
  condition.signal
end

3. `broadcast`メソッド

broadcastメソッドは、待機中のすべてのスレッドに通知を送るメソッドです。signalが一つのスレッドにのみ通知を送るのに対し、broadcastは待機中の全スレッドに一斉に通知を送ります。例えば、すべてのスレッドが同じ条件で待機している場合に、broadcastを使用して全スレッドを再開させることができます。

mutex.synchronize do
  # 全ての待機スレッドに通知
  condition.broadcast
end

メソッドの使い分け

  • wait：特定の条件が満たされるまでスレッドを待機させる際に使用。
  • signal：条件が整った時、待機しているスレッドのうち一つを再開させる際に使用。
  • broadcast：複数のスレッドが同じ条件で待機している場合に、全スレッドを再開させる際に使用。

ConditionVariableのこれらのメソッドを適切に組み合わせることで、複雑なスレッド間の同期制御が可能となり、並行処理のパフォーマンスと信頼性を向上させることができます。

条件変数を使ったスレッド待機の実装例

ConditionVariableを使うことで、特定の条件が整うまでスレッドを待機させ、条件が満たされた時点で他のスレッドに処理を続行させるといった制御が可能です。ここでは、ConditionVariableを利用したスレッド待機の具体的な実装例を紹介し、その動作を詳しく説明します。

以下の例では、ConditionVariableを使って「生産者と消費者」モデルを実装します。生産者スレッドがリソースを追加するまで、消費者スレッドは待機し、リソースが追加されるとその通知を受け取って処理を再開します。

コード例：生産者と消費者モデル

require 'thread'

mutex = Mutex.new
condition = ConditionVariable.new
shared_resource = []

producer = Thread.new do
  mutex.synchronize do
    puts "Producer: Generating resource..."
    shared_resource << "Resource"  # リソースを追加
    puts "Producer: Resource added."
    condition.signal  # 消費者に通知
  end
end

consumer = Thread.new do
  mutex.synchronize do
    while shared_resource.empty?
      puts "Consumer: Waiting for resource..."
      condition.wait(mutex)  # リソースが空の間は待機
    end
    puts "Consumer: Consumed #{shared_resource.pop}"
  end
end

[producer, consumer].each(&:join)

コードの流れ

  1. 初期設定
    MutexとConditionVariableを生成し、共有リソースとしてshared_resourceを空の配列で初期化します。producer（生産者）とconsumer（消費者）の二つのスレッドを作成します。
  2. 生産者スレッドの処理
    producerスレッドは、mutex.synchronizeでロックをかけ、shared_resourceに「Resource」という文字列を追加します。追加後、condition.signalを使ってconsumerスレッドに通知を送ります。この通知により、待機中のconsumerスレッドが処理を再開します。
  3. 消費者スレッドの待機と再開
    consumerスレッドもmutex.synchronizeでロックを取得し、shared_resourceが空である間、condition.wait(mutex)で待機します。producerスレッドからの通知を受けると、mutexが再びロックされ、待機が解除されます。待機解除後、shared_resourceからリソースを取り出して消費します。

コードの実行結果

以下は、このコードを実行した際の出力の一例です。

Consumer: Waiting for resource...
Producer: Generating resource...
Producer: Resource added.
Consumer: Consumed Resource

この例では、消費者スレッドが最初にリソースを要求し、リソースが追加されるまで待機します。生産者スレッドがリソースを生成すると、消費者スレッドが通知を受け取り、リソースを消費する動作を確認できます。

この実装のポイント

  • 待機中のロック解放：waitメソッドにより、待機中のスレッドはMutexのロックを解放するため、他のスレッドが同じリソースにアクセスできます。
  • 通知機構の活用：signalにより、待機中のスレッドに通知を送ることで、処理を円滑に続行させられます。

このように、ConditionVariableを利用して待機と通知の動作を実装することで、スレッド間での効率的なリソースのやり取りと同期処理が可能になります。

複数スレッド間のリソース共有と競合管理

複数のスレッドが同時に同じリソースにアクセスすると、リソースの内容が不整合になったり、データが破損したりするリスクがあります。このような問題を防ぐためには、適切なリソース共有と競合管理が必要です。ここでは、Rubyにおけるスレッド間のリソース共有と競合管理の基本概念と、それを安全に行う方法を解説します。

リソース共有の問題点

並行処理において、複数のスレッドが同じリソース（例：変数、配列、ファイルなど）にアクセスする際、次のような問題が発生する可能性があります。

  1. 競合状態（レースコンディション）
    2つ以上のスレッドが同時にリソースにアクセスして操作することで、予期しない動作や結果が発生することがあります。例えば、カウンタを増やす処理が競合してしまい、実際の値が不正になる場合があります。
  2. デッドロック
    複数のスレッドが相互にリソースをロックしたまま待機状態に入り、全体の処理が停止する状態です。デッドロックは、スレッド間のロックの順序や解放方法が適切でない場合に発生しやすくなります。
  3. リソース枯渇
    あるスレッドがリソースを独占してしまい、他のスレッドがリソースを利用できない状態が続く場合も問題です。これにより、他のスレッドの実行が著しく遅れたり、停止したりします。

安全なリソース共有の方法

Rubyで安全にリソースを共有し、競合状態を防ぐためには、MutexやConditionVariableを使ってスレッド間でのアクセスを制御することが有効です。

1. Mutexによる排他制御

Mutex（相互排他ロック）を使用することで、リソースにアクセスする際に他のスレッドが同時にアクセスできないようにします。以下は、Mutexを使って競合状態を防ぐ簡単な例です。

mutex = Mutex.new
shared_resource = 0

threads = 10.times.map do
  Thread.new do
    mutex.synchronize do
      temp = shared_resource
      sleep(0.1)  # 別のスレッドが割り込む可能性を示す
      shared_resource = temp + 1
    end
  end
end

threads.each(&:join)
puts shared_resource  # 正しい値が表示される

このコードでは、Mutex#synchronizeを使って、shared_resourceにアクセスする際に排他制御を行っています。これにより、スレッドが同時にリソースを更新することを防ぎ、予期せぬ値が書き込まれるのを防止します。

2. ConditionVariableによるスレッドの待機と通知

複数のスレッドが条件を待機する場合、ConditionVariableを使うことで安全な通知機構が利用できます。これにより、リソースが利用可能になるまで他のスレッドが待機し、リソースが準備できたら通知を送るといった制御が可能になります。

mutex = Mutex.new
condition = ConditionVariable.new
shared_resource = nil

producer = Thread.new do
  mutex.synchronize do
    shared_resource = "Resource created"
    condition.signal  # リソースが準備できたので通知
  end
end

consumer = Thread.new do
  mutex.synchronize do
    condition.wait(mutex) until shared_resource  # リソースが準備できるまで待機
    puts "Consumed: #{shared_resource}"
  end
end

[producer, consumer].each(&:join)

ここでは、consumerスレッドがshared_resourceの準備を待ち、producerスレッドがリソースを生成してから通知を送ることで、安全にリソースを共有しています。

競合管理のポイント

  • Mutexを使った排他制御を常に行い、複数のスレッドが同時にリソースへアクセスするのを防ぎます。
  • デッドロックを避けるため、リソースのロック順序を整理し、必要なリソースが全て取得できるように設計することが重要です。
  • 条件変数を活用した待機と通知を利用して、リソースが準備されていない場合に待機し、準備完了時に通知を送ることで効率的なスレッド管理を行います。

このような方法を組み合わせることで、Rubyにおける複数スレッド間での安全なリソース共有と競合管理が可能となり、安定した並列処理の実装が実現できます。

`ConditionVariable`を使った通知機構の実装

ConditionVariableを使うことで、特定の条件が満たされた際に待機しているスレッドに通知を送る通知機構を実装できます。この機能により、スレッド間の協調動作がスムーズに行われ、効率的なリソース利用が可能になります。ここでは、複数のスレッド間での通知機構を構築する実装例を紹介します。

以下の例では、複数の消費者スレッドがリソースが利用可能になるのを待機し、リソースが準備できたタイミングで通知を受け取って処理を再開する動作を実装しています。

コード例：複数消費者スレッドによる通知機構

require 'thread'

mutex = Mutex.new
condition = ConditionVariable.new
shared_resource = nil

producer = Thread.new do
  mutex.synchronize do
    puts "Producer: Preparing resource..."
    sleep(1)  # リソースを準備する処理
    shared_resource = "Resource is ready"
    puts "Producer: Resource is ready."
    condition.broadcast  # すべての待機スレッドに通知
  end
end

consumers = 3.times.map do |i|
  Thread.new do
    mutex.synchronize do
      puts "Consumer #{i + 1}: Waiting for resource..."
      condition.wait(mutex) until shared_resource  # リソースが準備されるまで待機
      puts "Consumer #{i + 1}: Consumed #{shared_resource}"
    end
  end
end

[producer, *consumers].each(&:join)

コードの動作説明

  1. プロデューサスレッドの動作
    producerスレッドは、mutex.synchronizeでリソースの準備処理を排他制御しながら行います。リソースが準備完了したら、condition.broadcastを呼び出し、待機しているすべてのconsumerスレッドに通知を送ります。このbroadcastメソッドは、待機中の複数のスレッドを一斉に再開させる役割を果たします。
  2. 複数の消費者スレッドの待機と通知の受信
    consumersは複数のスレッドとして定義され、それぞれがmutex.synchronizeでロックを取得した上で、condition.wait(mutex)でリソースが準備されるまで待機します。producerスレッドから通知が送られると、condition.waitが解除され、各消費者スレッドがshared_resourceを利用可能になります。

実行結果の例

このコードを実行すると、次のような出力が表示され、各スレッドがリソースを適切に待機・消費していることが確認できます。

Consumer 1: Waiting for resource...
Consumer 2: Waiting for resource...
Consumer 3: Waiting for resource...
Producer: Preparing resource...
Producer: Resource is ready.
Consumer 1: Consumed Resource is ready
Consumer 2: Consumed Resource is ready
Consumer 3: Consumed Resource is ready

ポイントと活用例

  • broadcastの活用：broadcastメソッドにより、複数のスレッドが一斉に再開できるため、リソースの利用準備が整った瞬間に複数の消費者が同時に動作を再開します。これにより、同時に通知が必要な複数のスレッドに効率的な通知を行えます。
  • 待機と通知による協調動作：複数の消費者がリソースの準備を待機し、リソースが利用可能になったタイミングで同期して動作するため、全体の処理の流れがスムーズになります。
  • リソースの準備状況を待機：プロデューサスレッドがリソースを準備するまで、消費者スレッドは無駄なリソース消費をせずに効率的に待機でき、準備完了後に一斉に処理を進めることができます。

このような通知機構を活用することで、複数のスレッド間での効率的な協調動作が可能になり、並行処理のパフォーマンスと安定性が大幅に向上します。

エラー処理とデバッグのポイント

スレッド間の同期処理では、競合状態やデッドロック、予期しないエラーなどの問題が発生しやすくなります。これらの問題は、処理が複数のスレッドで同時に進行するため、再現が難しく、デバッグが複雑になることが多いです。ここでは、Rubyにおけるスレッド同期処理でのエラー処理とデバッグのポイントについて詳しく解説します。

1. 競合状態の検出と防止

競合状態（レースコンディション）は、複数のスレッドが同時にリソースへアクセスすることで、予期しない動作が発生する問題です。競合状態を防ぐには、適切なロック機構を利用して排他制御を行う必要があります。

  • Mutexで排他制御：リソースにアクセスする部分をMutexで保護することで、他のスレッドが同時にアクセスするのを防ぎます。必要に応じて、Mutex#synchronizeメソッドでロックとロック解除を一括管理するのが安全です。
  • 競合状態の検出：テスト時に競合状態を検出するため、スレッドにわざと時間をかけさせる（例：sleepを挿入する）ことで、競合状態が発生しやすい状況を作り出すことが有効です。

2. デッドロックの防止

デッドロックは、複数のスレッドが相互にリソースをロックし合うことで発生し、処理が停止してしまう状態です。デッドロックを防ぐためには、以下の方法が有効です。

  • ロックの順序を統一する：複数のリソースをロックする場合、全てのスレッドが同じ順序でリソースをロックするように設計することで、デッドロックを防ぐことができます。
  • タイムアウトを設定：ConditionVariableを使用する場合、waitメソッドにタイムアウトを設定することで、指定時間内に条件が満たされない場合に処理を中断できます。これにより、デッドロックの発生を早期に検出できます。
mutex = Mutex.new
condition = ConditionVariable.new

mutex.synchronize do
  if condition.wait(mutex, 5) # 5秒以内に条件が満たされない場合
    puts "Timeout: Condition not met within the time limit"
  end
end

3. 例外処理の導入

スレッド内で例外が発生した場合、プログラム全体が異常終了することがあるため、例外処理を適切に実装することが重要です。

  • スレッド内の例外キャッチ：スレッド内で例外が発生する可能性がある場合、begin...rescueを使用して例外をキャッチし、エラーメッセージの記録やログ出力などを行います。
Thread.new do
  begin
    # スレッド内の処理
  rescue => e
    puts "Error in thread: #{e.message}"
  end
end
  • 全体の例外監視：複数のスレッドで動作するプログラムでは、特定のスレッドで発生したエラーを監視し、全体の処理に影響が出ないように管理する仕組みが求められます。

4. ログとデバッグ出力の活用

スレッドが絡む問題は再現が難しいため、ログやデバッグ出力を活用して実行状況を記録することが効果的です。

  • スレッドIDとタイムスタンプの記録：ログを記録する際、スレッドIDとタイムスタンプを含めることで、どのスレッドがいつ処理を実行していたかがわかりやすくなります。
puts "[#{Time.now}] Thread #{Thread.current.object_id}: Started"
  • 状態の可視化：putsやログライブラリを活用して、スレッドの状態やロックの状況を逐次出力することで、問題発生箇所を特定しやすくなります。

5. デバッグツールの活用

並行処理のデバッグを効率化するために、専用のデバッグツールを活用することも効果的です。Rubyでは、デバッグ用にbyebugなどのデバッガがあり、スレッドの実行状態を逐次確認できます。

  • byebugによるブレークポイントの設定：byebugを使用することで、特定の箇所で処理を一時停止し、スレッドの状態や変数の内容を確認できます。

まとめ

スレッドの同期処理において、エラー処理とデバッグは欠かせない要素です。MutexやConditionVariableの適切な利用と、エラーハンドリング・デバッグ手法を組み合わせることで、複雑な並行処理でも信頼性の高いプログラムを構築できます。

演習問題と解説

ConditionVariableを使ったスレッド同期処理の理解を深めるために、演習問題を通して実践的なスキルを身につけましょう。以下に、実際の開発現場でも役立つ問題を用意しました。解説もつけているので、各問題の意図や解答例を確認しながら進めてみてください。

演習問題 1：生産者と消費者の協調動作

問題
生産者スレッドがアイテムをリソースに追加し、消費者スレッドがアイテムを消費するように、ConditionVariableを使って生産者と消費者が協調して動作するプログラムを作成してください。生産者スレッドは、アイテムが既に存在する場合は追加を待機し、消費者スレッドはアイテムが追加されるまで待機します。

解答例

require 'thread'

mutex = Mutex.new
condition = ConditionVariable.new
shared_resource = nil

producer = Thread.new do
  5.times do |i|
    mutex.synchronize do
      while shared_resource
        condition.wait(mutex)  # リソースが空くまで待機
      end
      shared_resource = "Item #{i + 1}"
      puts "Producer added: #{shared_resource}"
      condition.signal  # 消費者に通知
    end
  end
end

consumer = Thread.new do
  5.times do
    mutex.synchronize do
      while shared_resource.nil?
        condition.wait(mutex)  # リソースが追加されるまで待機
      end
      puts "Consumer consumed: #{shared_resource}"
      shared_resource = nil
      condition.signal  # 生産者に通知
    end
  end
end

[producer, consumer].each(&:join)

解説
このプログラムでは、生産者と消費者が互いにアイテムの有無を確認しながら協調動作を行います。生産者がアイテムを追加すると、消費者に通知が送られ、消費者がそのアイテムを消費します。消費が完了すると、再度生産者に通知が送られ、新しいアイテムの追加が可能になります。この交互の動作により、アイテムが正確に追加・消費されます。

演習問題 2：複数の消費者を持つ通知機構

問題
複数の消費者スレッドが同じリソースの準備完了を待機し、リソースが利用可能になったら全ての消費者が通知を受け取って処理を再開するプログラムを作成してください。ConditionVariableのbroadcastメソッドを使用して、一斉に通知する仕組みを導入してください。

解答例

mutex = Mutex.new
condition = ConditionVariable.new
shared_resource = nil

producer = Thread.new do
  mutex.synchronize do
    puts "Producer preparing resource..."
    sleep(2)
    shared_resource = "Shared Resource"
    puts "Producer: Resource is ready."
    condition.broadcast  # すべての待機スレッドに通知
  end
end

consumers = 3.times.map do |i|
  Thread.new do
    mutex.synchronize do
      puts "Consumer #{i + 1}: Waiting for resource..."
      condition.wait(mutex) until shared_resource  # リソースが準備されるまで待機
      puts "Consumer #{i + 1}: Accessed #{shared_resource}"
    end
  end
end

[producer, *consumers].each(&:join)

解説
このプログラムでは、broadcastメソッドを使用して、すべての消費者スレッドにリソースの準備が完了したことを通知しています。producerスレッドがリソースを用意し、condition.broadcastで待機中の消費者スレッド全てに通知を送ります。これにより、複数の消費者がリソースを利用できる状態になり、全消費者が同時に処理を再開します。

まとめ

これらの演習問題を通して、ConditionVariableを使ったスレッドの待機・通知の仕組みや、複数スレッドの協調動作について理解を深めてください。実践的な例で理解を強化し、Rubyでのスレッド同期処理を安全かつ効果的に行えるようになりましょう。

まとめ

本記事では、RubyのConditionVariableを用いた複雑なスレッド同期処理について解説しました。ConditionVariableを使用することで、特定の条件が満たされるまでスレッドを待機させたり、他のスレッドに通知を送るといった高度な同期処理が可能になります。また、Mutexとの組み合わせによる排他制御、競合管理、デッドロックの防止、さらに複数のスレッドに対する一斉通知といった実践的なテクニックも紹介しました。

ConditionVariableの正しい利用は、並行処理の信頼性とパフォーマンスを向上させ、リソースを効率的に管理するうえで大変有効です。演習問題を通じて、スレッド間での同期と通知の重要性を実感し、実際の開発でも応用できるように学びを深めていきましょう。

Ruby
スレッド Ruby 同期処理

コメント

コメントする

目次