C++ 多线程锁

#include “thread”
#include “mutex”
#include “iostream”

//! std::thread
//! jion 阻塞式， .join()后面的代码等待线程结束
//! detach 非阻塞式， 后面代码继续执行

1. mutex

类型	说明
std::mutex	最基本的 Mutex 类。
std::recursive_mutex	递归 Mutex 类
std::time_mutex	定时 Mutex 类
std::recursive_timed_mutex	定时递归 Mutex 类。

std::mutex mtx;
int i = 0;

void add1()
{
    mtx.lock();
    for(int n = 0; n < 20; ++n)
        std::cout<<"add1 i = "<<++i<<std::endl;
    mtx.unlock();
}

void add2()
{
    mtx.lock();
    for(int n = 0; n < 20; ++n)
        std::cout<<"add2 i = "<<++i<<std::endl;
    mtx.unlock();
}

2. lock_guard

//! 创建即加锁，作用域结束自动析构并解锁，无需手工解锁
//! 不能中途解锁，必须等作用域结束才解锁
//! 不能复制

void add3()
{
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
    std::lock_guard<std::mutex> lockg(mtx);
    for(int n = 0; n < 20; ++n){
        std::cout<<"add3 i = "<<++i<<std::endl;
    }
}

void add4()
{
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
    std::lock_guard<std::mutex> lockg(mtx);
    for(int n = 0; n < 20; ++n){
        std::cout<<"add4 i = "<<++i<<std::endl;
    }
}

3. unique_lock 是 lock_guard 的升级加强版

//! 创建时可以不锁定（通过指定第二个参数为std::defer_lock），而在需要时再锁定
//! 可以随时加锁解锁
//! 作用域规则同 lock_grard，析构时自动释放锁
//! 不可复制，可移动
//! 条件变量需要该类型的锁作为参数（此时必须使用unique_lock）
//! std::adopt_lock （必须先加锁）
//! std::try_to_lock
//! std::defer_lock （必须手动加锁）

void add5()
{
    //! std::adopt_lock
    //mtx.lock();
    //std::unique_lock<std::mutex> ulock(mtx, std::adopt_lock);// 先加锁
    //! std::defer_lock
    //std::unique_lock<std::mutex> ulock(mtx, std::defer_lock);// 后手动加锁
    //ulock.lock();
    //!
    std::unique_lock<std::mutex> ulock(mtx);	//自动加锁
    for(int n = 0; n < 20; ++n)
        std::cout<<"add5 i = "<<++i<<std::endl;
}

void add6()
{
    //! std::adopt_lock
    //mtx.lock();
    //std::unique_lock<std::mutex> ulock(mtx, std::adopt_lock);
    //! std::defer_lock
    //std::unique_lock<std::mutex> ulock(mtx, std::defer_lock);
    //ulock.lock();
    //!
    std::unique_lock<std::mutex> ulock(mtx);
    for(int n = 0; n < 20; ++n)
        std::cout<<"add6 i = "<<++i<<std::endl;
}

4. condition_variable

std::condition_variable cv;
bool wait = false;

void printf1(int n)
{
    for (int i = 0; i < n; ++i) {
        std::unique_lock<std::mutex> ulock(mtx);
        if(wait) cv.wait(ulock);
        std::cout<<"printf1    " << i <<std::endl;
        wait = true;
        cv.notify_one();
    }
}

void printf2(int n)
{
    for (int i = 0; i < n; ++i) {
        std::unique_lock<std::mutex> ulock(mtx);
        if(!wait) cv.wait(ulock);
        std::cout<<"printf2    " << i+10 <<std::endl;
        wait = false;
        cv.notify_one();
    }
}

5. 调用

//! 1.mutex
    std::thread td(add1);
    std::thread td2(add2);
    td.join();
    td2.join();

//! 2. lock_guard
    std::thread td3(add3);
    std::thread td4(add4);
    td3.detach();
    td4.detach();

//! 3. unique_lock
std::thread td5(add5);
std::thread td6(add6);
td5.detach();
td6.detach();

//! 4. condition_variable + unique_lock
std::thread td7(printf1, 10);
std::thread td8(printf2, 10);
td7.detach();
td8.detach();