std::mutex (c++11) 

1. mutex を使ってみる

mutex と lock_guard を使って、シンプルな排他処理を行うプログラムを作成してみます。

自動的に unlock してくれるので、多くの場合でこの方法が最適です。

[環境]

最初に、うまく動かない例を示します。

こちら "bad_sample.cpp" はうまく動かない例です。4つのスレッドがそれぞれ 25,000回 のインクリメントをするので、最後に変数 count が 100,000 になることを期待するプログラムです。しかし同期処理がないために期待する動作をしない、という例です。

[プログラムソース] bad_sample.cpp

#include <iostream>     // std::cout, std::endl
#include <thread>       // std::thread
#include <cstdlib>      // EXIT_SUCCESS

// グローバル変数
volatile long           count = 0;

// カウントアップを行うスレッド関数
void CountThread(const size_t iterations)
{
    int x;
    for (size_t i = 0; i < iterations; ++i){
        x = count;
        // 問題を発生させにくい場合は次の行のコメントアウトを外してください。
        // std::this_thread::yield();      // スレッドの処理明け渡し。c++11。
        x++;
        count = x;
    }
}

// メイン関数
int main()
{
    const size_t    numThreads = 4;
    std::thread     countThreads[numThreads];

    // スレッドを4つ作成
    for (size_t i = 0; i < numThreads; ++i){
        countThreads[i] = std::thread(CountThread, 25000);
    }

    // 4つのスレッドが終わるのを待つ
    for (size_t i = 0; i < numThreads; ++i){
        countThreads[i].join();
    }

    // 4つのスレッドが終了したのちの count の値をチェック
    std::cout << "count = " << count << std::endl;
    
    return EXIT_SUCCESS;
}

ビルドおよび実行結果：

$ g++ -std=c++17 -Wall -Wextra -Wpedantic -pthread -O2 bad_sample.cpp -o bad_sample.out
$ ./bad_sample.out 
count = 72727
$ 

この実行例では、期待する 100,000 に対して実際には 72,727 という値になりました。

次に、mutex による同期処理を追加した例を紹介します。

[プログラムソース] good_sample_01.cpp

#include <iostream>     // std::cout, std::endl
#include <thread>       // std::thread
#include <cstdlib>      // EXIT_SUCCESS
#include <mutex>        // mutex, lock_guard

// グローバル変数
volatile long           count = 0;      // 共有変数
std::mutex              count_mutex;     // ミューテックス

// カウントアップを行うスレッド関数
void CountThread(const size_t iterations)
{
    int x;
    for (size_t i = 0; i < iterations; ++i){
        // ミューテックスをロックして count にアクセスします。
        std::lock_guard<std::mutex> guard(count_mutex);
        
        x = count;
        // 問題を発生させにくい場合は次の行のコメントアウトを外してください。
        // std::this_thread::yield();      // スレッドの処理明け渡し。c++11。
        x++;
        count = x;
    }
}

// メイン関数
int main()
{
    const size_t    numThreads = 4;
    std::thread     countThreads[numThreads];

    // スレッドを4つ作成
    for (size_t i = 0; i < numThreads; ++i){
        countThreads[i] = std::thread(CountThread, 25000);
    }

    // 4つのスレッドが終わるのを待つ
    for (size_t i = 0; i < numThreads; ++i){
        countThreads[i].join();
    }

    // 4つのスレッドが終了したのちの count の値をチェック
    std::cout << "count = " << count << std::endl;
    
    return EXIT_SUCCESS;
}

ビルドおよび実行結果：

$ g++ -std=c++17 -Wall -Wextra -Wpedantic -pthread -O2 good_sample_01.cpp -o good_sample_01.out
$ ./good_sample_01.out 
count = 100000
$ 

mutex による同期処理を加えることで、プログラム実行後の変数 count の値は期待する 100,000 となりました。

以上が mutex による同期処理を必要とする理由と効果の説明です。

2. mutex.lock, mutex.unlock

std::mutex.lock, std::mutex.unlock を使って排他処理を実装する例を紹介します。

[プログラムソース] good_sample_02.cpp

#include <iostream>     // std::cout, std::endl
#include <thread>       // std::thread
#include <cstdlib>      // EXIT_SUCCESS
#include <mutex>        // mutex

// グローバル変数
volatile long           count = 0;      // 共有変数
std::mutex              count_mutex;     // ミューテックス

// カウントアップを行うスレッド関数
void CountThread(const size_t iterations)
{
    int x;
    for (size_t i = 0; i < iterations; ++i){
        count_mutex.lock();  // ミューテックスをロックして count にアクセスします。

        x = count;
        // 問題を発生させにくい場合は次の行のコメントアウトを外してください。
        // std::this_thread::yield();      // スレッドの処理明け渡し。c++11。
        x++;
        count = x;

        count_mutex.unlock();  // ミューテックスのロックを解除します。
    }
}

// メイン関数
int main()
{
    const size_t    numThreads = 4;
    std::thread     countThreads[numThreads];

    // スレッドを4つ作成
    for (size_t i = 0; i < numThreads; ++i){
        countThreads[i] = std::thread(CountThread, 25000);
    }

    // 4つのスレッドが終わるのを待つ
    for (size_t i = 0; i < numThreads; ++i){
        countThreads[i].join();
    }

    // 4つのスレッドが終了したのちの count の値をチェック
    std::cout << "count = " << count << std::endl;
    
    return EXIT_SUCCESS;
}

ビルドおよび実行結果：

$ g++ -std=c++17 -Wall -Wextra -Wpedantic -pthread -O2 good_sample_02.cpp -o good_sample_02.out
$ ./good_sample_02.out 
count = 100000
$ 

3. mutex::try_lock

std::mutex::try_lock は、C++ の std::mutex クラスに属するメンバ関数で、ミューテックスをロックできるかどうかを試すための非ブロッキングな方法です。

• 成功時：ミューテックスのロックに成功すれば true を返す。
• 失敗時：すでに他のスレッドがロックしている場合は false を返す。
• ブロックしない：lock() のようにロックが解放されるまで待たず、すぐに結果を返す。

使いどころ：

• スレッドが他の作業を優先したいときに便利
• 例えば、リソースが使われていたら無理に待たずにスキップしたり、後回しにしたりできる
• デッドロック回避のために、複数のミューテックスを順番に try_lock で試す戦略にも使える

補足：

• 似た機能に std::try_lock があります。std::mutex::try_lock と機能や戻り値が異なるので取り扱いに注意が必要です。

[プログラムソース] try-lock_01.cpp

#include <chrono>
#include <iostream> // std::cout
#include <mutex>
#include <thread>
 
std::chrono::milliseconds interval(100);
 
std::mutex mutex;
int job_shared = 0;     // both threads can modify 'job_shared',
                        // mutex will protect this variable
 
int job_exclusive = 0;  // only one thread can modify 'job_exclusive'
                        // no protection needed
 
// this thread can modify both 'job_shared' and 'job_exclusive'
void job_1() 
{
    bool bLoop = true;
    std::this_thread::sleep_for(interval); // let 'job_2' take a lock
 
    while (bLoop)
    {
        // try to lock mutex to modify 'job_shared'
        if (mutex.try_lock())
        {
            std::cout << "job shared (" << job_shared << ")\n";
            mutex.unlock();
            bLoop = false; // finish after one successful modification;
        }
        else
        {
            // can't get lock to modify 'job_shared'
            // but there is some other work to do
            ++job_exclusive;
            std::cout << "job exclusive (" << job_exclusive << ")\n";
            std::this_thread::sleep_for(interval);
        }
    }

    return;
}
 
// this thread can modify only 'job_shared'
void job_2() 
{
    mutex.lock();
    std::this_thread::sleep_for(5 * interval);
    ++job_shared;
    mutex.unlock();
}
 
int main() 
{
    std::thread thread_1(job_1);
    std::thread thread_2(job_2);
 
    thread_1.join();
    thread_2.join();

    return 0;
}

ビルドおよび実行結果：

$ g++ -std=c++17 -Wall -Wextra -Wpedantic -pthread -O2 try-lock_01.cpp -o try-lock_01.out
$ ./try-lock_01.out 
job exclusive (1)
job exclusive (2)
job exclusive (3)
job exclusive (4)
job shared (1)
$ 

ライセンス

本ページの情報は、特記無い限り下記 MIT ライセンスで提供されます。

変更履歴

Programming Items トップページ

プライバシーポリシー