c++11 多線程

#c++11 多線程
引入多線程，對於跨平臺開發提供了很大的便捷

mutex lock

int g_i = 0;
std::mutex mm;
void add_one()
{
    for (size_t i = 0; i < 10; i++)
    {
        std::unique_lock<std::mutex> lck(mm);//默認創建時加鎖
        //do something with g_i++
        lck.unlock();

        std::this_thread::sleep_for(std::chrono::milliseconds(100));

        lck.lock();
        g_i ++ ;
        std::cout << g_i << " " << std::this_thread::get_id() << std::endl;
        lck.unlock();
    }
}

void lock_test()
{
    std::vector<std::thread> ver;
    int num = 0;
    for (auto i = 0; i < 5; ++i) {
        ver.emplace_back(add_one);
    }

    for (auto &t : ver) {
        t.join();
    }
}

mutex 種類

• std::mutex：最基本的mutex類。
• std::recursive_mutex：遞歸mutex類，能多次鎖定而不死鎖。
• std::time_mutex：定時mutex類，可以鎖定一定的時間。
• std::recursive_timed_mutex：定時遞歸mutex類。

另外，還提供了兩種鎖類型：

• std::lock_guard：方便線程對互斥量上鎖。
• std::unique_lock：方便線程對互斥量上鎖，但提供了更好的上鎖和解鎖控制。

add_one 中鎖的位置不同，打印輸出不同。鎖的範圍若加在整個for 裏，輸出回等到當前線程輸出完後接着下個線程輸出，不會多個線程輪換輸出。

condition_variable

std::condition_variable cv;
std::mutex cv_m; // This mutex is used for three purposes:
                 // 1) to synchronize accesses to i
                 // 2) to synchronize accesses to std::cerr
                 // 3) for the condition variable cv
int i = 0;

void waits()
{
    std::unique_lock<std::mutex> lk(cv_m);
    std::cerr << "Waiting... \n";
    cv.wait(lk, [] {return i == 1; });
    std::cerr << "...finished waiting. i == 1\n";
}

void signals()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
    {
        std::lock_guard<std::mutex> lk(cv_m);
        std::cerr << "Notifying...\n";
    }
    cv.notify_all();

    std::this_thread::sleep_for(std::chrono::seconds(1));

    {
        std::lock_guard<std::mutex> lk(cv_m);
        i = 1;
        std::cerr << "Notifying again...\n";
    }
    cv.notify_all();
}

void test_condiction()
{
    std::thread t1(waits), t2(waits), t3(waits), t4(signals);
    t1.join();
    t2.join();
    t3.join();
    t4.join();
}

condition 用於線程間同步，這裏wait 第二個參數lamda 表達式，只有表達式返回true,且被 notify時被喚醒。 目的是防止spurious wakeup，在POSIX Threads中多核系統中 條件競爭導致了虛假喚醒的發生

using namespace std::chrono_literals;

std::condition_variable wt_cv;
std::mutex wt_cv_m;
int wt_i = 0;

void wait_for(int idx)
{
    std::unique_lock<std::mutex> lk(wt_cv_m);
    if (wt_cv.wait_for(lk, idx * 100ms, [] {return wt_i == 1; }))
        std::cerr << "Thread " << idx << " finished waiting. wt_i == " << wt_i << '\n';
    else
        std::cerr << "Thread " << idx << " timed out. wt_i == " << wt_i << '\n';
}

void waitfor_signals()
{
    std::this_thread::sleep_for(120ms);
    std::cerr << "Notifying...\n";
    wt_cv.notify_all();
    std::this_thread::sleep_for(100ms);
    {
        std::lock_guard<std::mutex> lk(wt_cv_m);
        wt_i = 1;
    }
    std::cerr << "Notifying again...\n";
    wt_cv.notify_all();
}

void test_wait_for()
{
    std::thread t1(wait_for, 1), t2(wait_for, 2), t3(wait_for, 3), t4(waitfor_signals);
    t1.join();
    t2.join();
    t3.join();
    t4.join();
}

wait_for 還能加個超時等待時間來控制，這個功能強大，可以用來實現定時器。

atomic

當多線程訪問共享資源時，atomic 類型編譯器能保證對其操作是原子操作， 而且提供比mutex等鎖機制更好的性能，
reference: https://blog.csdn.net/yockie/article/details/8838686