【C++】std::mutex の使い方 | スレッド間の排他制御で競合を防ぐ方法

2025年8月29日

はじめに

マルチスレッドプログラミングでは、複数のスレッドが、グローバル変数のような共有リソースに同時にアクセスして値を変更しようとすると、データ競合（レースコンディション）が発生し、プログラム全体の整合性が壊れてしまいます。

例えば、あるカウンター変数を2つのスレッドが同時に「読み込み→1増やす→書き込み」という操作を行うと、更新が1回分失われて、最終的な値が期待通りにならない、といった問題が起こります。

この問題を解決するのが「排他制御」です。C++の標準ライブラリ <mutex> で提供されている std::mutex（ミューテックス）を使うことで、共有リソースへのアクセスを一度に一つのスレッドだけに限定（ロック）し、データの整合性を保つことができます。

`std::mutex` を使った排他制御のサンプルコード

このコードは、共有のカウンター shared_counter を、4つのスレッドがそれぞれインクリメント（1増やす）しようとするものです。std::mutex を使って、カウンターへのアクセスを保護します。

完成コード

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>

using namespace std;

// 1. 共有リソースを保護するためのミューテックスを準備
std::mutex mtx;
int shared_counter = 0;

// 共有リソースを操作するワーカースレッドの処理
void increment_counter() {
    for (int i = 0; i < 10000; ++i) {
        // 2. mutexをロックする
        mtx.lock();
        
        // --- クリティカルセクション ---
        // この区間は、一度に一つのスレッドしか実行できない
        shared_counter++;
        
        // 3. mutexをアンロックする
        mtx.unlock();
    }
}

int main() {
    // 4つのスレッドを作成し、実行を開始する
    vector<thread> threads;
    for (int i = 0; i < 4; ++i) {
        threads.emplace_back(increment_counter);
    }

    // 全てのスレッドが終了するのを待つ
    for (auto& th : threads) {
        th.join();
    }

    // 最終的なカウンターの値を表示
    // 正しく排他制御されていれば、40000になる
    cout << "最終的なカウンターの値: " << shared_counter << endl;

    return 0;
}

コードの解説

1. `std::mutex mtx;`

排他制御を行うためのミューテックスオブジェクトを宣言しています。この mtx が、共有リソースへのアクセスの「鍵」の役割を果たします。

2. `mtx.lock();`

スレッドが共有リソースにアクセスする前に、mtx の .lock() メソッドを呼び出します。

もし mtx が他のスレッドによって既にロックされていれば、このスレッドはここで処理を中断し、ロックが解放されるまで待機します。
ロックされていなければ、mtx をロック状態にして、次の行に進みます。

3. `mtx.unlock();`

共有リソースへのアクセスが終わったら、必ず .unlock() メソッドを呼び出して、他の待機しているスレッドのために「鍵」を解放する必要があります。

クリティカルセクション

lock() と unlock() で囲まれた区間を「クリティカルセクション」と呼びます。この区間内のコードは、ミューテックスによって保護され、複数のスレッドから同時に実行されることがなくなります。

もし `mutex` がなかったら？

もし lock() と unlock() の行をコメントアウトして実行すると、複数のスレッドが同時に shared_counter++ を実行しようとして更新が衝突し、最終的な結果は 40000 よりも少ない、不定な値になってしまいます。

より安全なロック管理 (`std::lock_guard`)

手動で lock() / unlock() を管理すると、処理の途中で例外が発生した場合などに unlock() が呼ばれず、デッドロックに陥る危険性があります。これを防ぐため、実際には std::lock_guard を使うのが、より安全で一般的な方法です。

void safe_increment() {
    for (int i = 0; i < 10000; ++i) {
        std::lock_guard<std::mutex> guard(mtx); // スコープに入ると自動でロック
        shared_counter++;
    } // スコープを抜けると自動でアンロック
}