[C++] queueをスレッドセーフにする方法

#include <iostream>
#include <queue>
#include <mutex>
#include <thread>
class ThreadSafeQueue {
public:
    void enqueue(int value) {
        std::lock_guard<std::mutex> lock(mutex_); // ミューテックスで排他制御
        queue_.push(value); // キューに値を追加
    }
    int dequeue() {
        std::lock_guard<std::mutex> lock(mutex_); // ミューテックスで排他制御
        if (queue_.empty()) {
            throw std::runtime_error("キューが空です"); // キューが空の場合のエラーハンドリング
        }
        int value = queue_.front(); // キューの先頭の値を取得
        queue_.pop(); // キューから値を削除
        return value; // 取得した値を返す
    }
private:
    std::queue<int> queue_; // 内部キュー
    std::mutex mutex_; // 排他制御用のミューテックス
};
int main() {
    ThreadSafeQueue tsQueue;
    tsQueue.enqueue(1);
    tsQueue.enqueue(2);
    std::cout << tsQueue.dequeue() << std::endl; // 1を出力
    std::cout << tsQueue.dequeue() << std::endl; // 2を出力
    return 0;
}

1
2

#include <iostream>
#include <queue>
#include <mutex>
#include <thread>
#include <vector>
class ThreadSafeQueue {
public:
    // 値をキューに追加するメソッド
    void enqueue(int value) {
        std::lock_guard<std::mutex> lock(mutex_); // ミューテックスで排他制御
        queue_.push(value); // キューに値を追加
    }
    // キューから値を取得するメソッド
    int dequeue() {
        std::lock_guard<std::mutex> lock(mutex_); // ミューテックスで排他制御
        if (queue_.empty()) {
            throw std::runtime_error("キューが空です"); // キューが空の場合のエラーハンドリング
        }
        int value = queue_.front(); // キューの先頭の値を取得
        queue_.pop(); // キューから値を削除
        return value; // 取得した値を返す
    }
private:
    std::queue<int> queue_; // 内部キュー
    std::mutex mutex_; // 排他制御用のミューテックス
};
// スレッドで実行する関数
void producer(ThreadSafeQueue& tsQueue, int id) {
    for (int i = 0; i < 5; ++i) {
        tsQueue.enqueue(i + id * 10); // 異なる値をキューに追加
        std::cout << "Producer " << id << " added: " << (i + id * 10) << std::endl;
    }
}
void consumer(ThreadSafeQueue& tsQueue, int id) {
    for (int i = 0; i < 5; ++i) {
        try {
            int value = tsQueue.dequeue(); // キューから値を取得
            std::cout << "Consumer " << id << " removed: " << value << std::endl;
        } catch (const std::runtime_error& e) {
            std::cout << "Consumer " << id << " error: " << e.what() << std::endl;
        }
    }
}
int main() {
    ThreadSafeQueue tsQueue;
    std::vector<std::thread> producers;
    std::vector<std::thread> consumers;
    // プロデューサースレッドの作成
    for (int i = 0; i < 2; ++i) {
        producers.emplace_back(producer, std::ref(tsQueue), i);
    }
    // コンシューマースレッドの作成
    for (int i = 0; i < 2; ++i) {
        consumers.emplace_back(consumer, std::ref(tsQueue), i);
    }
    // スレッドの終了を待機
    for (auto& producer : producers) {
        producer.join();
    }
    for (auto& consumer : consumers) {
        consumer.join();
    }
    return 0;
}

Producer 0 added: 0
Producer 0 added: 1
Consumer 0 removed: 0
Producer 1 added: 10
Consumer 1 removed: 1
...

#include <iostream>
#include <queue>
#include <mutex>
#include <thread>
#include <condition_variable>
#include <vector>
class ThreadSafeQueue {
public:
    // 値をキューに追加するメソッド
    void enqueue(int value) {
        {
            std::lock_guard<std::mutex> lock(mutex_); // ミューテックスで排他制御
            queue_.push(value); // キューに値を追加
        }
        cond_var_.notify_one(); // コンシューマーに通知
    }
    // キューから値を取得するメソッド
    int dequeue() {
        std::unique_lock<std::mutex> lock(mutex_); // ミューテックスで排他制御
        cond_var_.wait(lock, [this] { return !queue_.empty(); }); // キューが空でないことを待機
        int value = queue_.front(); // キューの先頭の値を取得
        queue_.pop(); // キューから値を削除
        return value; // 取得した値を返す
    }
private:
    std::queue<int> queue_; // 内部キュー
    std::mutex mutex_; // 排他制御用のミューテックス
    std::condition_variable cond_var_; // 条件変数
};
// スレッドで実行する関数
void producer(ThreadSafeQueue& tsQueue, int id) {
    for (int i = 0; i < 5; ++i) {
        tsQueue.enqueue(i + id * 10); // 異なる値をキューに追加
        std::cout << "Producer " << id << " added: " << (i + id * 10) << std::endl;
    }
}
void consumer(ThreadSafeQueue& tsQueue, int id) {
    for (int i = 0; i < 5; ++i) {
        int value = tsQueue.dequeue(); // キューから値を取得
        std::cout << "Consumer " << id << " removed: " << value << std::endl;
    }
}
int main() {
    ThreadSafeQueue tsQueue;
    std::vector<std::thread> producers;
    std::vector<std::thread> consumers;
    // プロデューサースレッドの作成
    for (int i = 0; i < 2; ++i) {
        producers.emplace_back(producer, std::ref(tsQueue), i);
    }
    // コンシューマースレッドの作成
    for (int i = 0; i < 2; ++i) {
        consumers.emplace_back(consumer, std::ref(tsQueue), i);
    }
    // スレッドの終了を待機
    for (auto& producer : producers) {
        producer.join();
    }
    for (auto& consumer : consumers) {
        consumer.join();
    }
    return 0;
}