[C++] マルチスレッド化におけるスレッドセーフなクラスを作成する方法

#include <iostream>
#include <thread>
#include <mutex>
class ThreadSafeCounter {
private:
    int count; // カウント値
    std::mutex mtx; // ミューテックス
public:
    ThreadSafeCounter() : count(0) {}
    void increment() {
        mtx.lock(); // ロックを取得
        ++count; // カウントを増加
        mtx.unlock(); // ロックを解放
    }
    int getCount() {
        mtx.lock(); // ロックを取得
        int temp = count; // カウント値を取得
        mtx.unlock(); // ロックを解放
        return temp;
    }
};
int main() {
    ThreadSafeCounter counter;
    std::thread t1([&counter]() { for (int i = 0; i < 1000; ++i) counter.increment(); });
    std::thread t2([&counter]() { for (int i = 0; i < 1000; ++i) counter.increment(); });
    t1.join();
    t2.join();
    std::cout << "最終カウント: " << counter.getCount() << std::endl;
    return 0;
}

最終カウント: 2000

#include <iostream>
#include <thread>
class ThreadLocalExample {
private:
    thread_local static int threadLocalCount; // スレッドローカル変数
public:
    void increment() {
        ++threadLocalCount; // スレッドローカル変数を増加
    }
    int getCount() const {
        return threadLocalCount; // スレッドローカル変数を取得
    }
};
thread_local int ThreadLocalExample::threadLocalCount = 0; // 初期化
int main() {
    ThreadLocalExample example;
    std::thread t1([&example]() { for (int i = 0; i < 1000; ++i) example.increment(); });
    std::thread t2([&example]() { for (int i = 0; i < 1000; ++i) example.increment(); });
    t1.join();
    t2.join();
    std::cout << "スレッド1のカウント: " << example.getCount() << std::endl;
    std::cout << "スレッド2のカウント: " << example.getCount() << std::endl;
    return 0;
}

スレッド1のカウント: 1000
スレッド2のカウント: 1000

#include <iostream>
#include <thread>
#include <atomic>
class AtomicCounter {
private:
    std::atomic<int> count; // アトミック変数
public:
    AtomicCounter() : count(0) {}
    void increment() {
        ++count; // アトミックにカウントを増加
    }
    int getCount() const {
        return count.load(); // アトミックにカウント値を取得
    }
};
int main() {
    AtomicCounter counter;
    std::thread t1([&counter]() { for (int i = 0; i < 1000; ++i) counter.increment(); });
    std::thread t2([&counter]() { for (int i = 0; i < 1000; ++i) counter.increment(); });
    t1.join();
    t2.join();
    std::cout << "最終カウント: " << counter.getCount() << std::endl;
    return 0;
}

最終カウント: 2000

#include <iostream>
#include <thread>
#include <mutex>
#include <queue>
#include <condition_variable>
template <typename T>
class ThreadSafeQueue {
private:
    std::queue<T> queue; // 内部キュー
    std::mutex mtx; // ミューテックス
    std::condition_variable cv; // 条件変数
public:
    void enqueue(T value) {
        std::lock_guard<std::mutex> lock(mtx); // ロックを取得
        queue.push(value); // キューに値を追加
        cv.notify_one(); // 待機中のスレッドに通知
    }
    T dequeue() {
        std::unique_lock<std::mutex> lock(mtx); // ロックを取得
        cv.wait(lock, [this] { return !queue.empty(); }); // キューが空でないことを待機
        T value = queue.front(); // キューの先頭を取得
        queue.pop(); // 先頭を削除
        return value; // 取得した値を返す
    }
};
void producer(ThreadSafeQueue<int>& queue) {
    for (int i = 0; i < 10; ++i) {
        queue.enqueue(i); // キューに値を追加
        std::cout << "生産者: " << i << " を追加しました。" << std::endl;
    }
}
void consumer(ThreadSafeQueue<int>& queue) {
    for (int i = 0; i < 10; ++i) {
        int value = queue.dequeue(); // キューから値を取得
        std::cout << "消費者: " << value << " を取り出しました。" << std::endl;
    }
}
int main() {
    ThreadSafeQueue<int> queue;
    std::thread t1(producer, std::ref(queue)); // 生産者スレッド
    std::thread t2(consumer, std::ref(queue)); // 消費者スレッド
    t1.join(); // 生産者スレッドの終了を待機
    t2.join(); // 消費者スレッドの終了を待機
    return 0;
}

生産者: 0 を追加しました。
生産者: 1 を追加しました。
生産者: 2 を追加しました。
生産者: 3 を追加しました。
生産者: 4 を追加しました。
生産者: 5 を追加しました。
生産者: 6 を追加しました。
生産者: 7 を追加しました。
生産者: 8 を追加しました。
生産者: 9 を追加しました。
消費者: 0 を取り出しました。
消費者: 1 を取り出しました。
消費者: 2 を取り出しました。
消費者: 3 を取り出しました。
消費者: 4 を取り出しました。
消費者: 5 を取り出しました。
消費者: 6 を取り出しました。
消費者: 7 を取り出しました。
消費者: 8 を取り出しました。
消費者: 9 を取り出しました。

#include <iostream>
#include <thread>
#include <vector>
#include <cassert>
#include <chrono>
class ThreadSafeCounter {
private:
    int count; // カウント値
    std::mutex mtx; // ミューテックス
public:
    ThreadSafeCounter() : count(0) {}
    void increment() {
        std::lock_guard<std::mutex> lock(mtx); // ロックを取得
        ++count; // カウントを増加
    }
    int getCount() {
        std::lock_guard<std::mutex> lock(mtx); // ロックを取得
        return count; // カウント値を取得
    }
};
void testCounter(ThreadSafeCounter& counter, int increments) {
    for (int i = 0; i < increments; ++i) {
        counter.increment(); // カウントを増加
    }
}
int main() {
    const int numThreads = 10; // スレッド数
    const int incrementsPerThread = 1000; // 各スレッドの増加回数
    ThreadSafeCounter counter; // スレッドセーフカウンター
    std::vector<std::thread> threads; // スレッドのベクター
    // スレッドを生成
    for (int i = 0; i < numThreads; ++i) {
        threads.emplace_back(testCounter, std::ref(counter), incrementsPerThread);
    }
    // スレッドの終了を待機
    for (auto& t : threads) {
        t.join();
    }
    // 最終カウントを検証
    int expectedCount = numThreads * incrementsPerThread; // 期待されるカウント
    int actualCount = counter.getCount(); // 実際のカウント
    std::cout << "期待されるカウント: " << expectedCount << std::endl;
    std::cout << "実際のカウント: " << actualCount << std::endl;
    // 結果の検証
    assert(expectedCount == actualCount); // 期待されるカウントと実際のカウントが一致することを確認
    return 0;
}

期待されるカウント: 10000
実際のカウント: 10000