C++ 多线程，互斥锁，死锁

#include <iostream>
#include <thread>
#include <vector>
#include <mutex> //互斥锁，同步机制，用于多线程之间的同步
//using namespace std;

std::mutex mtx;
static int cnt;

void work(int i)
{
    //当多个线程访问一个数据时，会产生数据竞争
    //加锁来同步数据资源，解决数据竞争问题

    //死锁1：加锁和解锁之间产生异常
    //死锁2：多个线程对多个mutex进行上锁，ABBA死锁
    //RAII利用C++语言局部对象自动销毁的特性，来控制资源的生命周期
    // lock_guard在构造函数中对mutex加锁，析构函数中对mutex解锁
    // lock_guard有三个构造函数
    std::lock_guard<std::mutex> my_lock(mtx); 
    // mtx.lock();
    // std::lock_guard<std::mutex> my_lock(mtx, std::adopt_lock)
    //cnt++;
    try
    {
        int* array = new int[1000];
        throw "exception";
    }

    catch(...) //...捕获所有异常
    {
        std::cout << "handle exception" << std::endl;
       // mtx.unlock(); //解决死锁，在函数返回前加解锁
        return;
    }
    //mtx.unlock();

    
    //cout是共享资源
    //在访问标准输出之前加锁，访问结束之后解锁
    //在同一时间，只有一个线程可以拥有这把锁
    // mtx.lock(); //加锁
    // std::cout << "do some work... arg: " << i 
    // << " id: " << std::this_thread::get_id() 
    // << std::endl;
    // mtx.unlock(); //解锁

    //printf("this is from thread %d \n", i); //printf线程安全
}

int main() //主线程
{
    int thread_num = std::thread::hardware_concurrency();
    std::cout << "thread num supported by hardware: " 
    << thread_num << std::endl;

    // std::thread worker(work, 10); //子线程
    // //join 和 detach 只能用一个且在main结束之前必须用一个
    // worker.join();

    // //与主线程分离，后台独立运行，不受主线程控制
    // //子线程与主线程运行速度不一致，需要同步机制
    // worker.detach(); 
    
    // if(worker.joinable()){ //判断是否可以join
    //     worker.join();
    // }

    std::vector<std::thread> workers;
    for(int i = 0; i < 16; i++){
        workers.push_back(std::thread(work,i));
    }
        for(int i = 0; i < 16; i++){
            workers[i].join();
    }
    std::cout << "main thread, cnt:  " << cnt << std::endl;
    
    system("pause");
    return 0;
}

进程有独立的虚拟地址空间，是线程运行的容器。线程是具体执行流程，由一系列函数运行组成，main函数开始的线程称为主线程，进程至少有一个线程运行。线程运行的本质是函数运行，进程由一系列函数运行组成，进程负责资源分配，线程CPU任务调度；线程栈帧、程序计数器、栈帧、线程寄存器是线程私有；线程共享进程空间中的全局、静态变量，其他函数代码，堆区空间