[c++多线程并发 基础入门] 1.2 互斥量mutex, 原子变量atomic

1. 没有mutex

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

int globalVariable = 0;

void task1()
{
    for(int i = 0; i < 1000000; i++)
 	{
        globalVariable++;
        globalVariable--;
    }
}

int main(int argc, const char * argv[]) 
{
    std::thread t1(task1);
    std::thread t2(task1);
    
    t1.join();
    t2.join();
    
    std::cout<<"current value is "<<globalVariable<<std::endl;
}

xcode, command+r 运行结果为1，本来++和-- ，最后结果为0才对的，但是最后结果为1。
current value is 1
Program ended with exit code: 0

2. 加上互斥量mutex

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

std::mutex mtx;
int globalVariable = 0;

void task1()
{
    for(int i = 0; i < 1000000; i++)
    {
        mtx.lock();
        globalVariable++;
        globalVariable--;
        mtx.unlock();
    }
}

int main(int argc, const char * argv[]) {

    std::thread t1(task1);
    std::thread t2(task1);
    
    t1.join();
    t2.join();
    
    std::cout<<"current value is "<<globalVariable<<std::endl;
}

macOS xcode, command+r 运行结果为0, 正确。
current value is 1

锁之间的代码(上锁和解锁之间的代码段)叫做临界区代码段:
globalVariable++;
globalVariable–;

一般不直接使用互斥量mutex, 而是搭配着和lock_guard 和 unique_lock使用，防止自己忘记解锁，导致死锁。

3. 死锁

目前这里很简单，只有两行，实际情况可能复杂：
临界区代码段:

mtx.lock();
globalVariable++;
globalVariable--;
//callAFUNC(); throw

//if(1==1)
//{
//return;
//}
mtx.unlock();

情况一：
callAFUNC(); throw
调用函数后抛出异常，后面没有解锁

情况二：
if(1==1)
{
return;
}
有return, 直接返回，也没有解锁

情况三：

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

std::mutex mtx1;
std::mutex mtx2;
int globalVariable = 0;

void task1()
{
    for(int i = 0; i < 1000000; i++)
    {
        mtx1.lock();
        mtx2.lock();
        globalVariable++;
        globalVariable--;
        
        mtx1.unlock();
        mtx2.unlock();
    }
}

void task2()
{
    for(int i = 0; i < 1000000; i++)
    {
        mtx2.lock();
        mtx1.lock();
        globalVariable++;
        globalVariable--;
        
        mtx2.unlock();
        mtx1.unlock();
    }
}

int main(int argc, const char * argv[]) 
{
    std::thread t1(task1);
    std::thread t2(task2);
    
    t1.join();
    t2.join();
    
    std::cout<<"current value is "<<globalVariable<<std::endl;
}

task1中先对mtx1 上锁，task2中先对mtx2上锁，然后task1中再想对mtx2上锁，task2中对mtx1上锁，这样会产生矛盾，陷入矛盾，下面的代码不能执行，上锁顺序不同产生死锁。

4. 解决死锁情况

4.1std::lock_guardstd::mutex
对于情况一 情况二，程序中途满足某些提条件退出，没来得及解锁情况，可以用程序标准库中提供的std::lock_guardstd::mutex lock(mtx1) 来管理互斥量

std::lock_guard<std::mutex> lock1(mtx1)
std::lock_guard<std::mutex> lock2(mtx2)

lock_guard类 即对象创建的时候加锁，析构的时候会解锁，程序不需要再写 .lock() 和 .unlock() 这些了。

lock_guardstd::mutex 有自己的作用域

4.2std::unique_lock
std::unique_lockstd::mutex lock3(mtx1)

同样是模板类，构造函数中同样传入互斥量。

lock_guard 类对象lock1没有什么成员函数，只有析构成员函数~lock_guard(), lock_guard 这个类的作用域是整个for循环，如果想要在中途时刻解锁，那么这时候lock_guard 这个类就无法完成。

而unique_lock可以提供成员函数unlock(), release()

unlock() ：
1.可以在超出作用域之前就可以使用它进行解锁
2.可以记录锁当前的状态，是在锁还是解锁状态

4.3 lock_guard 和 unique_lock 区别：
1.unique_lock 用法更在丰富，同时支持std::lock_guard()的原有功能。
2.使用std::lock_guard后不能手动lock()与手动unlock()
3.使用std::unique_lock后可以手动lock()与手动unlock()

5 atomic 原子变量

可以让我们不去使用互斥量 锁 来实现对资源的原子操作，对存在资源竞争的变量改造

std::atomic<int> globalVariable = 0;

atomic内部实现原理(取决于具体标准库实现)：
1）上锁 解锁 保护
2）CPU, 硬件部分指定的原子操作保证的

例子：
#include
#include
#include
#include

std::mutex mtx1;
std::mutex mtx2;

std::atomic globalVariable = 0;

//int globalVariable = 0;

void task1()
{
for(int i = 0; i < 1000000; i++)
{
globalVariable++;
globalVariable–;
}
}

int main(int argc, const char * argv[]) {

std::thread t1(task1);
std::thread t2(task1);

t1.join();
t2.join();

std::cout<<"current value is "<<globalVariable<<std::endl;

}