[C++] マルチスレッドでスレッドセーフな同期処理の書き方

#include <iostream>
#include <thread>
void threadFunction() {
    std::cout << "スレッドが実行中です。" << std::endl;
}
int main() {
    std::thread myThread(threadFunction); // スレッドを作成
    myThread.join(); // スレッドの終了を待機
    return 0;
}

スレッドが実行中です。

#include <iostream>
#include <thread>
#include <mutex>
std::mutex myMutex; // ミューテックスの宣言
int sharedResource = 0; // 共有リソース
void incrementResource() {
    myMutex.lock(); // ミューテックスをロック
    ++sharedResource; // 共有リソースのインクリメント
    myMutex.unlock(); // ミューテックスをアンロック
}
int main() {
    std::thread threads[10];
    for (int i = 0; i < 10; ++i) {
        threads[i] = std::thread(incrementResource); // スレッドを作成
    }
    for (int i = 0; i < 10; ++i) {
        threads[i].join(); // スレッドの終了を待機
    }
    std::cout << "最終的な共有リソースの値: " << sharedResource << std::endl;
    return 0;
}

最終的な共有リソースの値: 10

#include <iostream>
#include <thread>
#include <mutex>
std::mutex myMutex; // ミューテックスの宣言
int sharedResource = 0; // 共有リソース
void incrementResource() {
    std::lock_guard<std::mutex> lock(myMutex); // 自動的にロック
    ++sharedResource; // 共有リソースのインクリメント
}
int main() {
    std::thread threads[10];
    for (int i = 0; i < 10; ++i) {
        threads[i] = std::thread(incrementResource); // スレッドを作成
    }
    for (int i = 0; i < 10; ++i) {
        threads[i].join(); // スレッドの終了を待機
    }
    std::cout << "最終的な共有リソースの値: " << sharedResource << std::endl;
    return 0;
}

最終的な共有リソースの値: 10

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
std::mutex myMutex; // ミューテックスの宣言
std::condition_variable cv; // 条件変数
bool ready = false; // スレッドの準備状態
void worker() {
    std::unique_lock<std::mutex> lock(myMutex); // ロックを取得
    cv.wait(lock, [] { return ready; }); // 準備が整うまで待機
    std::cout << "ワーカーが実行中です。" << std::endl;
}
int main() {
    std::thread workerThread(worker); // ワーカースレッドを作成
    std::this_thread::sleep_for(std::chrono::seconds(1)); // 1秒待機
    {
        std::lock_guard<std::mutex> lock(myMutex); // ロックを取得
        ready = true; // 準備完了
    }
    cv.notify_one(); // ワーカースレッドに通知
    workerThread.join(); // スレッドの終了を待機
    return 0;
}

ワーカーが実行中です。

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
std::mutex myMutex; // ミューテックスの宣言
std::condition_variable cv; // 条件変数
bool ready = false; // スレッドの準備状態
void worker() {
    std::unique_lock<std::mutex> lock(myMutex); // ロックを取得
    cv.wait(lock, [] { return ready; }); // 準備が整うまで待機
    std::cout << "ワーカーが実行中です。" << std::endl;
}
int main() {
    std::thread workerThread(worker); // ワーカースレッドを作成
    std::this_thread::sleep_for(std::chrono::seconds(1)); // 1秒待機
    {
        std::lock_guard<std::mutex> lock(myMutex); // ロックを取得
        ready = true; // 準備完了
    }
    cv.notify_one(); // ワーカースレッドに通知
    workerThread.join(); // スレッドの終了を待機
    return 0;
}

ワーカーが実行中です。

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <vector>
std::mutex myMutex; // ミューテックスの宣言
std::condition_variable cv; // 条件変数
bool ready = false; // スレッドの準備状態
void worker(int id) {
    std::unique_lock<std::mutex> lock(myMutex); // ロックを取得
    cv.wait(lock, [] { return ready; }); // 準備が整うまで待機
    std::cout << "ワーカー " << id << " が実行中です。" << std::endl;
}
int main() {
    const int numWorkers = 5;
    std::vector<std::thread> workers; // ワーカースレッドのベクター
    for (int i = 0; i < numWorkers; ++i) {
        workers.emplace_back(worker, i); // ワーカースレッドを作成
    }
    std::this_thread::sleep_for(std::chrono::seconds(1)); // 1秒待機
    {
        std::lock_guard<std::mutex> lock(myMutex); // ロックを取得
        ready = true; // 準備完了
    }
    cv.notify_all(); // 全てのワーカースレッドに通知
    for (auto& worker : workers) {
        worker.join(); // スレッドの終了を待機
    }
    return 0;
}

ワーカー 0 が実行中です。
ワーカー 1 が実行中です。
ワーカー 2 が実行中です。
ワーカー 3 が実行中です。
ワーカー 4 が実行中です。

#include <iostream>
#include <thread>
#include <shared_mutex>
#include <vector>
std::shared_mutex rwMutex; // 共有ミューテックス
int sharedData = 0; // 共有データ
void reader(int id) {
    std::shared_lock<std::shared_mutex> lock(rwMutex); // 共有ロックを取得
    std::cout << "リーダー " << id << " がデータを読み取ります: " << sharedData << std::endl;
}
void writer(int value) {
    std::unique_lock<std::shared_mutex> lock(rwMutex); // 排他ロックを取得
    sharedData = value; // データの書き込み
    std::cout << "ライターがデータを書き込みました: " << sharedData << std::endl;
}
int main() {
    std::vector<std::thread> threads;
    
    // リーダースレッドの作成
    for (int i = 0; i < 5; ++i) {
        threads.emplace_back(reader, i);
    }
    
    // ライタースレッドの作成
    threads.emplace_back(writer, 42);
    
    for (auto& thread : threads) {
        thread.join(); // スレッドの終了を待機
    }
    
    return 0;
}

リーダー 0 がデータを読み取ります: 0
リーダー 1 がデータを読み取ります: 0
リーダー 2 がデータを読み取ります: 0
リーダー 3 がデータを読み取ります: 0
リーダー 4 がデータを読み取ります: 0
ライターがデータを書き込みました: 42

#include <iostream>
#include <thread>
#include <barrier>
#include <vector>
std::barrier syncBarrier(5); // バリアの作成
void worker(int id) {
    std::cout << "スレッド " << id << " が準備中です。" << std::endl;
    syncBarrier.arrive_and_wait(); // バリアに到達
    std::cout << "スレッド " << id << " が再開します。" << std::endl;
}
int main() {
    std::vector<std::thread> threads;
    
    for (int i = 0; i < 5; ++i) {
        threads.emplace_back(worker, i); // スレッドを作成
    }
    
    for (auto& thread : threads) {
        thread.join(); // スレッドの終了を待機
    }
    
    return 0;
}

スレッド 0 が準備中です。
スレッド 1 が準備中です。
スレッド 2 が準備中です。
スレッド 3 が準備中です。
スレッド 4 が準備中です。
スレッド 0 が再開します。
スレッド 1 が再開します。
スレッド 2 が再開します。
スレッド 3 が再開します。
スレッド 4 が再開します。

#include <iostream>
#include <thread>
#include <future>
void calculate(std::promise<int>& prom) {
    int result = 42; // 計算結果
    prom.set_value(result); // 結果を設定
}
int main() {
    std::promise<int> prom; // プロミスの作成
    std::future<int> fut = prom.get_future(); // フューチャーを取得
    
    std::thread worker(calculate, std::ref(prom)); // スレッドを作成
    worker.detach(); // スレッドをデタッチ
    
    int result = fut.get(); // 結果を取得
    std::cout << "計算結果: " << result << std::endl;
    
    return 0;
}

計算結果: 42

#include <iostream>
#include <thread>
#include <atomic>
#include <vector>
std::atomic<int> counter(0); // アトミック変数
void increment() {
    for (int i = 0; i < 1000; ++i) {
        ++counter; // アトミックなインクリメント
    }
}
int main() {
    std::vector<std::thread> threads;
    
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(increment); // スレッドを作成
    }
    
    for (auto& thread : threads) {
        thread.join(); // スレッドの終了を待機
    }
    
    std::cout << "最終的なカウンターの値: " << counter.load() << std::endl; // 値を取得
    return 0;
}

最終的なカウンターの値: 10000

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
std::mutex counterMutex; // カウンタ用のミューテックス
int counter = 0; // 共有カウンタ
// カウンタをインクリメントする関数
void incrementCounter(int increments) {
    for (int i = 0; i < increments; ++i) {
        std::lock_guard<std::mutex> lock(counterMutex); // ミューテックスをロック
        ++counter; // カウンタのインクリメント
    }
}
int main() {
    const int numThreads = 10; // スレッドの数
    const int incrementsPerThread = 1000; // 各スレッドがインクリメントする回数
    std::vector<std::thread> threads; // スレッドのベクター
    // スレッドの作成
    for (int i = 0; i < numThreads; ++i) {
        threads.emplace_back(incrementCounter, incrementsPerThread); // スレッドを作成
    }
    // スレッドの終了を待機
    for (auto& thread : threads) {
        thread.join();
    }
    // 最終的なカウンタの値を出力
    std::cout << "最終的なカウンタの値: " << counter << std::endl; // 期待される値は10000
    return 0;
}

最終的なカウンタの値: 10000