MENU
  1. ホーム
  2. Rust
  3. RustでのCondvarを用いたスレッド間の条件付き同期処理を徹底解説

RustでのCondvarを用いたスレッド間の条件付き同期処理を徹底解説

Rust

スレッド間の同期処理は、並行プログラム開発における重要なテーマです。複数のスレッドが同時にリソースを共有したり、タスクを協調して処理したりする場合、適切な同期を行わないと、データ競合やデッドロックなどの問題が発生します。Rustは、安全で効率的な並行処理をサポートする言語として設計されており、Condvar（条件変数）はその一つの強力なツールです。本記事では、Condvarの基礎から応用例までを網羅し、スレッド間の条件付き同期処理の実践的な知識を提供します。Rust初心者から中級者まで、並行処理を安全かつ効率的に実現したい方に役立つ内容となっています。

目次
  1. スレッド間の同期とは
    1. 同期処理が必要な理由
    2. Rustにおける同期機能
  2. `Condvar`とは何か
    1. `Condvar`の特徴
    2. `Condvar`の一般的な用途
    3. 使用例の概要
  3. `Condvar`の基本的な使い方
    1. コード例: `Condvar`の基本操作
    2. コードのポイント
    3. 実行結果
  4. `Condvar`を使ったスレッド間通信の仕組み
    1. 例: スレッド間のデータ共有と通知
    2. 仕組みの詳細
    3. 実行結果
    4. 活用のポイント
  5. 注意すべきポイントとトラブルシューティング
    1. 注意すべきポイント
    2. トラブルシューティング
    3. ベストプラクティス
  6. 応用例: 生産者-消費者モデルの実装
    1. 生産者-消費者モデルとは
    2. 実装例
    3. コードのポイント
    4. 実行結果
    5. モデルの利点
  7. 他の同期方法との比較
    1. 1. `Mutex`
    2. 2. チャネル（`std::sync::mpsc`）
    3. 3. アトミック操作（`std::sync::atomic`）
    4. 4. RwLock
    5. 比較表
    6. 選択のポイント
  8. 演習問題: `Condvar`を使った簡易キューの作成
    1. 課題
    2. テンプレートコード
    3. 課題のヒント
    4. 期待される実行結果
    5. 解答例と解説
  9. まとめ
    1. 主な内容の振り返り
    2. 実践的な演習
    3. 今後のステップ

スレッド間の同期とは


スレッド間の同期とは、複数のスレッドが同時に実行される状況で、共有リソースへのアクセスを調整し、整合性を保つための仕組みです。同期処理を適切に実装することで、データ競合や不整合、デッドロックといった問題を防ぎ、プログラムの安定性と効率性を向上させることができます。

同期処理が必要な理由


並行処理では、次のような状況で同期が求められます。

  • 共有データの整合性を保つ：複数のスレッドが同じデータを同時に操作する場合、不整合を防ぐ必要があります。
  • タスクの実行順序を制御する：特定の処理が他の処理よりも先に行われる必要がある場合、同期を利用します。
  • リソースの安全な共有：ファイルやネットワーク接続などの共有リソースへの競合を防ぎます。

Rustにおける同期機能


Rustはスレッド間の安全な同期を支援するため、以下の機能を提供しています。

  • Mutex: リソースの排他制御を提供します。
  • RwLock: 読み取りと書き込みの同期を管理します。
  • Condvar: 条件付きの同期処理を可能にします。

この中でもCondvarは、条件が満たされるまでスレッドを待機させる場合や、条件が満たされた際にスレッドを通知する場合に利用されます。次のセクションでは、このCondvarについて詳しく解説します。

`Condvar`とは何か


Condvar（条件変数）は、Rustの標準ライブラリが提供する同期プリミティブの一つで、スレッド間の通信や協調に役立つ機能を持っています。特定の条件が満たされるまでスレッドを待機させる、または条件が満たされたことを他のスレッドに通知するために使用されます。

`Condvar`の特徴

  • 条件付きの待機：特定の条件が満たされるまでスレッドを停止させることができます。
  • 通知機能：条件が満たされた際に、待機中のスレッドに通知を送ることが可能です。
  • 他の同期プリミティブと組み合わせて使用：通常、CondvarはMutexと一緒に使用されます。Mutexで共有データのロックを管理し、Condvarで条件の待機や通知を行います。

`Condvar`の一般的な用途

  • スレッド間の協調：生産者-消費者モデルのように、あるスレッドが他のスレッドの処理を待つ場合に適しています。
  • リソースの制御：特定のリソースが利用可能になるまでスレッドをブロックし、リソースが利用可能になったら通知を送ることでスレッドを再開します。
  • イベントの通知：条件が変化した際に他のスレッドに知らせる役割を果たします。

使用例の概要


Condvarは、以下のようにMutexと組み合わせて使用されます。

  1. Mutexで共有リソースのロックを取得します。
  2. 条件が満たされていない場合、Condvarのwaitメソッドでスレッドをブロックします。
  3. 他のスレッドが条件を満たす処理を行い、notify_oneやnotify_allで待機中のスレッドを通知します。

次のセクションでは、Condvarの具体的な使い方をコード例とともに解説します。

`Condvar`の基本的な使い方


Condvarを用いることで、スレッド間で条件付きの同期処理を簡単に実現できます。ここでは、Condvarの基本的な使い方をシンプルなコード例とともに解説します。

コード例: `Condvar`の基本操作


以下は、Condvarを使用して条件が満たされるまでスレッドを待機させる例です。

use std::sync::{Arc, Condvar, Mutex};
use std::thread;

fn main() {
    // 共有データと同期プリミティブ
    let pair = Arc::new((Mutex::new(false), Condvar::new()));

    // クローンして他のスレッドに渡す
    let pair_clone = Arc::clone(&pair);

    // 新しいスレッドを生成
    let handle = thread::spawn(move || {
        let (lock, cvar) = &*pair_clone;
        let mut ready = lock.lock().unwrap();
        println!("スレッド: 条件を待っています...");
        while !*ready {
            ready = cvar.wait(ready).unwrap();
        }
        println!("スレッド: 条件が満たされました！");
    });

    // メインスレッドで条件を変更
    let (lock, cvar) = &*pair;
    {
        let mut ready = lock.lock().unwrap();
        println!("メイン: 条件を変更します...");
        *ready = true;
    }
    cvar.notify_one(); // 通知を送信

    handle.join().unwrap(); // スレッドの終了を待機
}

コードのポイント

  1. Arcの使用: 共有データを複数のスレッド間で安全に共有するため、Arcを使用します。
  2. MutexとCondvarの組み合わせ: Mutexでデータを保護し、Condvarで条件を待機または通知します。
  3. waitメソッド: 条件が満たされるまでスレッドを停止させます。このメソッドは、ロックを一時的に解放して他のスレッドがデータを操作できるようにします。
  4. notify_oneメソッド: 待機中のスレッドを再開させます。

実行結果

スレッド: 条件を待っています...
メイン: 条件を変更します...
スレッド: 条件が満たされました！

このように、Condvarを利用すると、スレッド間で条件付きの同期処理を簡潔に実装できます。次のセクションでは、より実践的な用途であるスレッド間通信の仕組みについて詳しく解説します。

`Condvar`を使ったスレッド間通信の仕組み


Condvarは、スレッド間の条件付き同期に特化したツールであり、共有データを介したスレッド間通信の実現に非常に役立ちます。このセクションでは、Condvarを利用したスレッド間通信の仕組みを、より具体的な例で説明します。

例: スレッド間のデータ共有と通知


以下のコードは、スレッド間で共有データをやり取りし、条件が満たされた際に通知を送る例です。

use std::sync::{Arc, Condvar, Mutex};
use std::thread;
use std::time::Duration;

fn main() {
    // 共有データと同期プリミティブ
    let shared_data = Arc::new((Mutex::new(None), Condvar::new()));

    // データ生成スレッド
    let producer = {
        let shared_data = Arc::clone(&shared_data);
        thread::spawn(move || {
            let (lock, cvar) = &*shared_data;
            let mut data = lock.lock().unwrap();
            println!("プロデューサー: データを生成しています...");
            *data = Some(42); // データを生成
            cvar.notify_one(); // 通知を送信
            println!("プロデューサー: データを生成しました！");
        })
    };

    // データ消費スレッド
    let consumer = {
        let shared_data = Arc::clone(&shared_data);
        thread::spawn(move || {
            let (lock, cvar) = &*shared_data;
            let mut data = lock.lock().unwrap();
            println!("コンシューマー: データを待機中...");
            while data.is_none() {
                data = cvar.wait(data).unwrap(); // データが生成されるまで待機
            }
            println!("コンシューマー: データを受信しました: {:?}", data);
        })
    };

    producer.join().unwrap();
    consumer.join().unwrap();
}

仕組みの詳細

  1. 共有データの初期化
  • Arcを利用して共有データ（Mutexで保護）を安全に他のスレッドに渡します。
  • 初期状態では、データはNoneとして定義されています。
  1. プロデューサースレッド
  • データを生成し、Mutexで保護された共有データに格納します。
  • データを格納した後、notify_oneメソッドで待機中のスレッドに通知を送ります。
  1. コンシューマースレッド
  • データがNoneである間、Condvarのwaitメソッドを使用して待機します。
  • データが設定されると、notify_oneの通知を受け取り、処理を再開します。

実行結果

プロデューサー: データを生成しています...
プロデューサー: データを生成しました！
コンシューマー: データを待機中...
コンシューマー: データを受信しました: Some(42)

活用のポイント

  • ロックの適切な管理: 待機中のMutexは自動的に解放されるため、デッドロックの可能性が低減します。
  • 条件の明示: 共有データの状態を条件として明示的に管理することで、プログラムの可読性が向上します。

このように、Condvarを使用すると、スレッド間で安全かつ効率的なデータ通信が可能になります。次のセクションでは、Condvar利用時の注意点やトラブルシューティングについて解説します。

注意すべきポイントとトラブルシューティング


Condvarはスレッド間の同期に便利なツールですが、適切に使用しないとデッドロックや無限待機などの問題が発生する可能性があります。このセクションでは、Condvarを使用する際に注意すべきポイントと、よくあるトラブルの解決方法を解説します。

注意すべきポイント

1. 必ず`Mutex`と併用する

  • Condvarは共有データを安全に操作するためにMutexと併用する必要があります。
  • 共有データの状態を適切に保護することで、予期しない競合を防ぎます。

2. ループで条件を確認する

  • Condvar::waitはスレッドを一時的にロック解除しますが、通知を受けた際に再びロックを取得します。
  • スプリアスウェイクアップ（誤通知）の可能性があるため、whileループを使用して条件を再確認することが推奨されます。
  while !condition {
      condition = cvar.wait(condition).unwrap();
  }

3. 適切な通知方法を選ぶ

  • notify_one: 単一の待機スレッドを再開させる場合に使用します。
  • notify_all: 全ての待機スレッドを再開させる場合に使用します。
  • シナリオに応じて適切なメソッドを選択することで、無駄なスレッドの実行を防ぎます。

4. デッドロックを回避する

  • スレッド間で複数のロックを同時に取得する場合、ロックの順序が異なるとデッドロックが発生する可能性があります。
  • ロックの取得順序を統一するか、複数のロックを避ける設計にすることで問題を回避します。

トラブルシューティング

1. スレッドが無限に待機する

  • 原因: 条件が正しく更新されていない、または通知が送られていない可能性があります。
  • 解決方法:
  • 共有データの更新とnotify_oneまたはnotify_allの呼び出しが正しい順序で行われているか確認します。
  • 条件が正しく評価されるか、デバッグログを出力して確認します。

2. スプリアスウェイクアップが発生する

  • 原因: 外部要因やシステムの動作により、条件が満たされていないのに待機が終了する場合があります。
  • 解決方法:
  • 必ずwhileループで条件を再確認するコードを記述します。

3. デッドロックが発生する

  • 原因: ロックの取得順序が一致していない場合に発生します。
  • 解決方法:
  • ロックの取得順序を統一する。
  • デッドロックを防ぐ設計（シングルロック設計やロックフリーの方法）を採用する。

ベストプラクティス

  • スレッド間通信に関する設計をシンプルに保ち、条件が明確になるようコードを記述する。
  • スレッド間の依存関係を最小限に抑え、必要以上のロックを取得しない設計を心掛ける。

これらの注意点を理解し、適切な設計を行うことで、Condvarを安全かつ効率的に使用できます。次のセクションでは、Condvarを利用した応用例として、生産者-消費者モデルを実装します。

応用例: 生産者-消費者モデルの実装


Condvarを利用すると、生産者-消費者モデルのような典型的なスレッド間の協調問題を簡潔に解決できます。このセクションでは、Condvarを使って生産者と消費者が共有データをやり取りするプログラムを実装します。

生産者-消費者モデルとは

  • 生産者: データを生成して共有キューに追加します。
  • 消費者: キューからデータを取得して処理します。
  • 課題: キューが満杯のときに生産者が待機し、キューが空のときに消費者が待機する必要があります。

実装例


以下のコードは、固定サイズのキューを共有し、生産者と消費者がCondvarを使用して同期を行う例です。

use std::collections::VecDeque;
use std::sync::{Arc, Condvar, Mutex};
use std::thread;
use std::time::Duration;

const QUEUE_CAPACITY: usize = 5;

fn main() {
    // 共有データと同期プリミティブ
    let shared_queue = Arc::new((
        Mutex::new(VecDeque::new()),
        Condvar::new(),
        Condvar::new(),
    ));

    // 生産者スレッド
    let producer = {
        let shared_queue = Arc::clone(&shared_queue);
        thread::spawn(move || {
            for i in 0..10 {
                let (queue, not_empty, not_full) = &*shared_queue;
                let mut queue = queue.lock().unwrap();

                while queue.len() == QUEUE_CAPACITY {
                    println!("生産者: キューが満杯です。待機します...");
                    queue = not_full.wait(queue).unwrap();
                }

                println!("生産者: データ {} を生成しました。", i);
                queue.push_back(i);
                not_empty.notify_one();
                thread::sleep(Duration::from_millis(100));
            }
        })
    };

    // 消費者スレッド
    let consumer = {
        let shared_queue = Arc::clone(&shared_queue);
        thread::spawn(move || {
            for _ in 0..10 {
                let (queue, not_empty, not_full) = &*shared_queue;
                let mut queue = queue.lock().unwrap();

                while queue.is_empty() {
                    println!("消費者: キューが空です。待機します...");
                    queue = not_empty.wait(queue).unwrap();
                }

                let value = queue.pop_front().unwrap();
                println!("消費者: データ {} を処理しました。", value);
                not_full.notify_one();
                thread::sleep(Duration::from_millis(150));
            }
        })
    };

    producer.join().unwrap();
    consumer.join().unwrap();
}

コードのポイント

  1. 共有キューの保護
  • Mutex<VecDeque>を利用してキューの操作を安全に管理します。
  1. Condvarの役割
  • not_empty: キューにデータが追加された際に消費者を通知します。
  • not_full: キューに空きができた際に生産者を通知します。
  1. 条件付き待機
  • 生産者はキューが満杯の場合に待機します。
  • 消費者はキューが空の場合に待機します。

実行結果

生産者: データ 0 を生成しました。
消費者: データ 0 を処理しました。
生産者: データ 1 を生成しました。
消費者: データ 1 を処理しました。
生産者: データ 2 を生成しました。
...

モデルの利点

  • 効率的なリソース利用: 生産者と消費者が無駄なく協調動作します。
  • スレッドの安全性: MutexとCondvarによる明確な制御でデータ競合が防止されます。

このように、Condvarを利用すると、スレッド間で条件付きの同期を必要とする実装を簡潔に行うことができます。次のセクションでは、Condvarと他の同期方法を比較し、それぞれの特性を解説します。

他の同期方法との比較


Rustでは、Condvar以外にも複数の同期手段が用意されています。それぞれの同期方法には特徴があり、適切な場面で使い分けることが重要です。このセクションでは、Condvarを他の同期方法と比較し、その特性を解説します。

1. `Mutex`

  • 概要: 共有データへの排他制御を提供します。単純にデータの保護を目的とする場合に使用されます。
  • 特徴:
  • ロックを取得したスレッドだけが共有データを操作可能です。
  • スレッド間の通知や待機機能はありません。
  • 適用場面:
  • 単純にリソースを保護する場合。
  • 条件付きの待機や通知が不要な場合。

`Mutex`と`Condvar`の違い

  • CondvarはMutexと組み合わせて使用されますが、条件の待機や通知を追加で提供します。
  • 通常のMutexでは、条件が満たされるまでロックを保持したままスピンロックを行う必要があり、非効率的です。Condvarはこの問題を解消します。

2. チャネル（`std::sync::mpsc`）

  • 概要: メッセージパッシングによる同期を提供します。スレッド間でデータを直接送受信するのに適しています。
  • 特徴:
  • 非同期でスレッド間通信が可能。
  • スレッドが送受信時にブロックされるかどうかを制御可能。
  • 適用場面:
  • データの共有ではなく、スレッド間でメッセージを送信する必要がある場合。
  • 生産者-消費者モデルのような、明確なデータフローがある場合。

`Condvar`とチャネルの違い

  • Condvarは条件付きの同期を提供する一方で、チャネルはデータ通信を簡単に行える仕組みを提供します。
  • 生産者-消費者モデルを実装する場合、チャネルの方が直感的でコードがシンプルになることがあります。

3. アトミック操作（`std::sync::atomic`）

  • 概要: 高速なロックフリーの操作を提供します。スレッド間で共有する値を直接操作する場合に使用されます。
  • 特徴:
  • AtomicUsizeなどを使用してデータの更新をスレッド間で安全に行えます。
  • 条件付きの同期や複雑なリソース管理には不向き。
  • 適用場面:
  • カウンタやフラグのような単純な値の同期が必要な場合。

`Condvar`とアトミック操作の違い

  • Condvarは条件待機や通知に特化しているのに対し、アトミック操作はシンプルな値の同期を行います。
  • Condvarは柔軟性が高い一方で、アトミック操作は軽量かつ効率的です。

4. RwLock

  • 概要: 共有データへの同時読み取りと排他的書き込みをサポートします。
  • 特徴:
  • 複数のスレッドがデータを読み取り可能。
  • 書き込み時は排他制御が適用されます。
  • 適用場面:
  • 読み取り頻度が高く、書き込みが少ない場合。

`Condvar`と`RwLock`の違い

  • Condvarは条件付き同期で動的なスレッド間通信を実現するために使用されます。
  • RwLockは同時に複数のスレッドがデータを安全に読み取る必要がある場合に適しています。

比較表


以下はCondvarと他の同期方法の特徴をまとめた表です。

同期方法主な用途条件付き同期メッセージ通信ロックフリー
Condvar条件付き同期処理◯✗✗
Mutexリソースの保護✗✗✗
チャネルデータ通信✗◯✗
アトミック操作単純な値の同期✗✗◯
RwLock同時読み取りと排他書き込み✗✗✗

選択のポイント

  • 複雑な条件付き同期: Condvarを使用。
  • 簡単な排他制御: Mutexを使用。
  • スレッド間通信: チャネルを使用。
  • 軽量な値の同期: アトミック操作を使用。
  • 読み取り中心の共有データ: RwLockを使用。

これらを考慮して、目的に合った同期方法を選択することが、効率的で安全な並行処理の実現に繋がります。次のセクションでは、演習問題としてCondvarを用いた簡易キューの作成に挑戦します。

演習問題: `Condvar`を使った簡易キューの作成


ここでは、Condvarを使用してスレッド間で動作する簡易的なキューを実装する演習を行います。この演習を通じて、Condvarの仕組みや実用的な使い方を深く理解することができます。

課題


以下の仕様を満たす簡易キューを実装してください。

  1. キューの容量を指定できる。
  2. キューにデータを追加する際、容量がいっぱいであればスレッドを待機させる。
  3. キューからデータを取り出す際、キューが空であればスレッドを待機させる。
  4. スレッド間で安全に動作する。

テンプレートコード


以下に、実装のベースとなるコードを示します。TODO部分を完成させてください。

use std::collections::VecDeque;
use std::sync::{Arc, Condvar, Mutex};
use std::thread;
use std::time::Duration;

struct SimpleQueue<T> {
    queue: Mutex<VecDeque<T>>,
    cond_var_not_empty: Condvar,
    cond_var_not_full: Condvar,
    capacity: usize,
}

impl<T> SimpleQueue<T> {
    fn new(capacity: usize) -> Self {
        SimpleQueue {
            queue: Mutex::new(VecDeque::new()),
            cond_var_not_empty: Condvar::new(),
            cond_var_not_full: Condvar::new(),
            capacity,
        }
    }

    fn enqueue(&self, item: T) {
        let mut queue = self.queue.lock().unwrap();
        while queue.len() == self.capacity {
            queue = self.cond_var_not_full.wait(queue).unwrap();
        }
        queue.push_back(item);
        self.cond_var_not_empty.notify_one();
    }

    fn dequeue(&self) -> T {
        let mut queue = self.queue.lock().unwrap();
        while queue.is_empty() {
            queue = self.cond_var_not_empty.wait(queue).unwrap();
        }
        let item = queue.pop_front().unwrap();
        self.cond_var_not_full.notify_one();
        item
    }
}

fn main() {
    let queue = Arc::new(SimpleQueue::new(3));

    let producer = {
        let queue = Arc::clone(&queue);
        thread::spawn(move || {
            for i in 0..10 {
                println!("生産者: データ {} を追加します。", i);
                queue.enqueue(i);
                thread::sleep(Duration::from_millis(100));
            }
        })
    };

    let consumer = {
        let queue = Arc::clone(&queue);
        thread::spawn(move || {
            for _ in 0..10 {
                let value = queue.dequeue();
                println!("消費者: データ {} を処理しました。", value);
                thread::sleep(Duration::from_millis(150));
            }
        })
    };

    producer.join().unwrap();
    consumer.join().unwrap();
}

課題のヒント

  • 共有リソースの保護: Mutexでキューをロックし、データ競合を防ぎます。
  • 条件付き待機: キューの状態に応じてCondvarを使用し、適切に待機や通知を行います。
  • エラー処理: 実装中に発生する可能性のあるエラーをログに出力すると、問題の特定が容易になります。

期待される実行結果

生産者: データ 0 を追加します。
生産者: データ 1 を追加します。
生産者: データ 2 を追加します。
消費者: データ 0 を処理しました。
生産者: データ 3 を追加します。
消費者: データ 1 を処理しました。
...

解答例と解説


コードが完成したら、スレッド間の動作をデバッグしながら、正しく動作していることを確認してください。この演習を通じて、Condvarを利用した条件付き同期の実装スキルが向上するはずです。次のセクションでは、この演習の内容を振り返り、記事をまとめます。

まとめ


本記事では、RustにおけるCondvarを使用したスレッド間の条件付き同期処理について解説しました。Condvarは、特定の条件が満たされるまでスレッドを待機させ、条件が満たされた際に他のスレッドを再開させるための強力なツールです。以下のポイントを学びました。

主な内容の振り返り

  • Condvarの基本的な使い方: CondvarはMutexと併用して使用し、スレッド間で条件付きの同期を行います。条件が満たされるまでスレッドを待機させ、条件が満たされると通知を送って待機しているスレッドを再開させます。
  • スレッド間通信の仕組み: Condvarを使うことで、生産者-消費者モデルのようにスレッド間で効率的なデータのやり取りが可能となります。
  • トラブルシューティングのポイント: Condvarを使用する際の注意点として、スレッドが無限に待機しないように条件を適切に確認することや、デッドロックを避けるためのロック取得順序の重要性についても学びました。
  • 他の同期方法との比較: Condvarは、Mutex、チャネル、アトミック操作、RwLockといった他の同期手段と用途に応じて使い分けることができます。それぞれの方法の特性を理解し、適切な方法を選ぶことが並行処理の効率的な実装に繋がります。

実践的な演習

  • 簡易キューの実装: 演習問題では、Condvarを使って簡易的な生産者-消費者モデルを実装しました。この演習を通じて、Condvarを利用した同期処理の実践的な活用方法を学びました。

今後のステップ


Condvarを使った並行処理は、特に複雑な条件付きの同期が必要な場合に非常に役立ちます。今後は、実際のプロジェクトにおいてCondvarを使った設計を行い、より複雑な並行処理に挑戦してみてください。

Rust
スレッド Rust 同期処理 Condvar

コメント

コメントする

目次
  1. スレッド間の同期とは
    1. 同期処理が必要な理由
    2. Rustにおける同期機能
  2. `Condvar`とは何か
    1. `Condvar`の特徴
    2. `Condvar`の一般的な用途
    3. 使用例の概要
  3. `Condvar`の基本的な使い方
    1. コード例: `Condvar`の基本操作
    2. コードのポイント
    3. 実行結果
  4. `Condvar`を使ったスレッド間通信の仕組み
    1. 例: スレッド間のデータ共有と通知
    2. 仕組みの詳細
    3. 実行結果
    4. 活用のポイント
  5. 注意すべきポイントとトラブルシューティング
    1. 注意すべきポイント
    2. トラブルシューティング
    3. ベストプラクティス
  6. 応用例: 生産者-消費者モデルの実装
    1. 生産者-消費者モデルとは
    2. 実装例
    3. コードのポイント
    4. 実行結果
    5. モデルの利点
  7. 他の同期方法との比較
    1. 1. `Mutex`
    2. 2. チャネル（`std::sync::mpsc`）
    3. 3. アトミック操作（`std::sync::atomic`）
    4. 4. RwLock
    5. 比較表
    6. 選択のポイント
  8. 演習問題: `Condvar`を使った簡易キューの作成
    1. 課題
    2. テンプレートコード
    3. 課題のヒント
    4. 期待される実行結果
    5. 解答例と解説
  9. まとめ
    1. 主な内容の振り返り
    2. 実践的な演習
    3. 今後のステップ