C++11多线程并发基础知识

缺乏、安全感 2023-01-16 02:55 145阅读 0赞

## **C++多线程并发基础知识** ##

### **1.创建线程** ###

首先要引入头文件**\#include<thread>，**C++11中管理线程的函数和类在该头文件中声明，其中包括std::thread类。

例：std::thread th1(proc1)创建了一个名为th1的线程，并且线程th1开始执行。

实例化std::thread类对象时，至少需要传递函数名作为参数。如果函数为有参函数,如 void proc2(int a,int b)，那么实例化std::thread类对象时，则需要传递更多参数，参数顺序依次为函数名、该函数的第一个参数、该函数的第二个参数，···，如 std::thread th2(proc2,a,b)。

join()与detach()都是std::thread类的成员函数，是两种线程阻塞方法，两者的区别是是否等待子线程执行结束。

等待调用线程运行结束后当前线程再继续运行，例如，主函数中有一条语句th1.join()，那么执行到这里，主函数阻塞，直到线程th1运行结束，主函数再继续运行。

**只要构造了std::thread对象（前提是，实例化std::thread对象时传递了“函数名/可调用对象”作为参数），线程就开始执行；当线程启动后，一定要在和线程相关联的std::thread对象销毁前，对线程运用join()或者detach()方法。**

**代码示例：**

#include<iostream>
    #include<thread>
    using namespace std;
    void proc(int &a)
    {
        cout << "我是子线程,传入参数为" << a << endl;
        cout << "子线程中显示子线程id为" << this_thread::get_id()<< endl;
    }
    int main()
    {
        cout << "我是主线程" << endl;
        int a = 9;
        thread th2(proc,a);//第一个参数为函数名，第二个参数为该函数的第一个参数，如果该函数接收多个参数就依次写在后面。此时线程开始执行。
        cout << "主线程中显示子线程id为" << th2.get_id() << endl;
        th2.join()；//此时主线程被阻塞直至子线程执行结束。
        return 0;
    }

调用join()会清理线程相关的存储部分，这代表了join()只能调用一次。使用joinable()来判断join()可否调用。同样，detach()也只能调用一次，一旦detach()后就无法join()了，有趣的是，detach()可否调用也是使用joinable()来判断。

### 2.互斥量使用 ###

首先包含头文件\#include<mutex>，然后需要实例化std::mutex对象，最后需要在进入临界区之前对互斥量加锁，退出临界区时对互斥量解锁；

**2.1lock()与unlock()**

#include<iostream>
    #include<thread>
    #include<mutex>
    using namespace std;
    mutex m;//实例化m对象，不要理解为定义变量
    void proc1(int a)
    {
        m.lock();
        cout << "proc1函数正在改写a" << endl;
        cout << "原始a为" << a << endl;
        cout << "现在a为" << a + 2 << endl;
        m.unlock();
    }
    
    void proc2(int a)
    {
        m.lock();
        cout << "proc2函数正在改写a" << endl;
        cout << "原始a为" << a << endl;
        cout << "现在a为" << a + 1 << endl;
        m.unlock();
    }
    int main()
    {
        int a = 0;
        thread proc1(proc1, a);
        thread proc2(proc2, a);
        proc1.join();
        proc2.join();
        return 0;
    }

需要在进入临界区之前对互斥量lock，退出临界区时对互斥量unlock；当一个线程使用特定互斥量锁住共享数据时，其他的线程想要访问锁住的数据，都必须等到之前那个线程对数据进行解锁后，才能进行访问。不推荐直接去调用成员函数lock()，因为如果忘记unlock()，将导致锁无法释放，**使用lock\_guard或者unique\_lock则能避免忘记解锁带来的问题。**

**2.2std::lock\_guard**

其原理是：在其构造函数中进行加锁，作用域结束后自动析构进行解锁；**通过使用\{\}来调整作用域范围，可使得互斥量std::mutex在合适的地方被解锁。**

#include<iostream>
    #include<thread>
    #include<mutex>
    using namespace std;
    mutex m;//实例化m对象，不要理解为定义变量
    void proc1(int a)
    {
        lock_guard<mutex> g1(m);//用此语句替换了m.lock()；lock_guard传入一个参数时，该参数为互斥量，此时调用了lock_guard的构造函数，申请锁定m
        cout << "proc1函数正在改写a" << endl;
        cout << "原始a为" << a << endl;
        cout << "现在a为" << a + 2 << endl;
    }//此时不需要写m.unlock(),g1出了作用域被释放，自动调用析构函数，于是m被解锁
    
    void proc2(int a)
    {
        {
            lock_guard<mutex> g2(m);
            cout << "proc2函数正在改写a" << endl;
            cout << "原始a为" << a << endl;
            cout << "现在a为" << a + 1 << endl;
        }//通过使用{}来调整作用域范围，可使得m在合适的地方被解锁
        cout << "作用域外的内容3" << endl;
        cout << "作用域外的内容4" << endl;
        cout << "作用域外的内容5" << endl;
    }
    int main()
    {
        int a = 0;
        thread proc1(proc1, a);
        thread proc2(proc2, a);
        proc1.join();
        proc2.join();
        return 0;
    }

std::lock\_gurad也可以传入两个参数，第二个参数为adopt\_lock标识时，表示构造函数中不再进行互斥量锁定，因此**此时需要提前手动锁定**。

#include<iostream>
    #include<thread>
    #include<mutex>
    using namespace std;
    mutex m;//实例化m对象，不要理解为定义变量
    void proc1(int a)
    {
        m.lock();//手动锁定
        lock_guard<mutex> g1(m,adopt_lock);
        cout << "proc1函数正在改写a" << endl;
        cout << "原始a为" << a << endl;
        cout << "现在a为" << a + 2 << endl;
    }//自动解锁
    
    void proc2(int a)
    {
        lock_guard<mutex> g2(m);//自动锁定
        cout << "proc2函数正在改写a" << endl;
        cout << "原始a为" << a << endl;
        cout << "现在a为" << a + 1 << endl;
    }//自动解锁
    int main()
    {
        int a = 0;
        thread proc1(proc1, a);
        thread proc2(proc2, a);
        proc1.join();
        proc2.join();
        return 0;
    }

**2.3std::unique\_lock**

std::unique\_lock类似于std::lock\_guard，只是std::unique\_lock用法更加丰富，同时支持std::lock\_guard()的原有功能。

*  使用std::lock\_guard后不能手动lock()与手动unlock()
 *  使用std::unique\_lock后可以手动lock()与手动unlock()
 *  std::unique\_lock的第二个参数，除了可以是adopt\_lock，还可以是try\_to\_lock与defer\_lock

**try\_to\_lock:** 尝试去锁定，**得保证锁处于unlock的状态，**然后尝试现在能不能获得锁；尝试用mutex的lock()去锁定这个mutex，但如果没有锁定成功，会立即返回，不会阻塞在那里，并继续往下执行。

**defer\_lock:** 初始化了一个没有加锁的mutex。

#include<iostream>
    #include<thread>
    #include<mutex>
    using namespace std;
    mutex m;
    void proc1(int a)
    {
        unique_lock<mutex> g1(m, defer_lock);//始化了一个没有加锁的mutex
        cout << "xxxxxxxx" << endl;
        g1.lock();//手动加锁，注意，不是m.lock();注意，不是m.lock(),m已经被g1接管了;
        cout << "proc1函数正在改写a" << endl;
        cout << "原始a为" << a << endl;
        cout << "现在a为" << a + 2 << endl;
        g1.unlock();//临时解锁
        cout << "xxxxx"  << endl;
        g1.lock();
        cout << "xxxxxx" << endl;
    }//自动解锁
    
    void proc2(int a)
    {
        unique_lock<mutex> g2(m,try_to_lock);//尝试加锁一次，但如果没有锁定成功，会立即返回，不会阻塞在那里，且不会再次尝试锁操作。
        if(g2.owns_lock){//锁成功
            cout << "proc2函数正在改写a" << endl;
            cout << "原始a为" << a << endl;
            cout << "现在a为" << a + 1 << endl;
        }else{//锁失败则执行这段语句
            cout <<""<<endl;
        }
    }//自动解锁
    
    int main()
    {
        int a = 0;
        thread proc1(proc1, a);
        thread proc2(proc2, a);
        proc1.join();
        proc2.join();
        return 0;
    }

使用try\_to\_lock要小心，因为try\_to\_lock尝试锁失败后不会阻塞线程，而是继续往下执行程序，因此，需要使用if-else语句来判断是否锁成功，只有锁成功后才能去执行互斥代码段。而且需要注意的是，因为try\_to\_lock尝试锁失败后代码继续往下执行了，因此该语句不会再次去尝试锁。

std::unique\_lock所有权的转移

注意，这里的转移指的是**std::unique\_lock对象间**的转移；std::mutex对象的所有权不需要手动转移给std::unique\_lock , std::unique\_lock对象实例化后会直接接管std::mutex。

mutex m;
    {  
        unique_lock<mutex> g2(m,defer_lock);
        unique_lock<mutex> g3(move(g2));//所有权转移，此时由g3来管理互斥量m
        g3.lock();
        g3.unlock();
        g3.lock();
    }

**condition\_variable**

需要\#include<condition\_variable>，该头文件中包含了条件变量相关的类，其中包括std::condition\_variable类。

std::condition\_variable类搭配std::mutex类来使用，std::condition\_variable对象的作用不是用来管理互斥量的，它的作用是用来同步线程。

类比到std::condition\_variable，A、B两个人约定notify\_one为行动号角，A就等着（调用wait(),阻塞），只要B一调用notify\_one，A就开始行动（不再阻塞）。

wait(locker) :wait函数需要传入一个std::mutex（一般会传入std::unique\_lock对象），即上述的locker。wait函数会自动调用 locker.unlock() 释放锁（因为需要释放锁，所以要传入mutex）并阻塞当前线程，本线程释放锁使得其他的线程得以继续竞争锁。一旦当前线程获得notify(通常是另外某个线程调用 notify\_\* 唤醒了当前线程)，wait() 函数此时再自动调用 locker.lock()上锁。

cond.notify\_one(): 随机唤醒一个等待的线程

cond.notify\_all(): 唤醒所有等待的线程

### 3.异步线程 ###

需要\#include<future>

**3.1async与future**

std::async是一个函数模板，用来启动一个异步任务，它返回一个std::future类模板对象，future对象起到了**占位**的作用（记住这点就可以了），占位是什么意思？就是说该变量现在无值，但将来会有值（好比你挤公交瞧见空了个座位，刚准备坐下去就被旁边的小伙给拦住了：“这个座位有人了”，你反驳道：”这不是空着吗？“，小伙：”等会人就来了“）,刚实例化的future是没有储存值的，但在调用std::future对象的get()成员函数时，主线程会被阻塞直到异步线程执行结束，并把返回结果传递给std::future，即通过FutureObject.get()获取函数返回值。

相当于你去办政府办业务（主线程），把资料交给了前台，前台安排了人员去给你办理（std::async创建子线程），前台给了你一个单据（std::future对象），说你的业务正在给你办（子线程正在运行），等段时间你再过来凭这个单据取结果。过了段时间，你去前台取结果（调用get()），但是结果还没出来（子线程还没return），你就在前台等着（阻塞），直到你拿到结果（子线程return），你才离开（不再阻塞）。

#include <iostream>
    #include <thread>
    #include <mutex>
    #include<future>
    #include<Windows.h>
    using namespace std;
    double t1(const double a, const double b)
    {
     double c = a + b;
     Sleep(3000);//假设t1函数是个复杂的计算过程，需要消耗3秒
     return c;
    }
    
    int main() 
    {
     double a = 2.3;
     double b = 6.7;
     future<double> fu = async(t1, a, b);//创建异步线程线程，并将线程的执行结果用fu占位；
     cout << "正在进行计算" << endl;
     cout << "计算结果马上就准备好，请您耐心等待" << endl;
     cout << "计算结果：" << fu.get() << endl;//阻塞主线程，直至异步线程return
            //cout << "计算结果：" << fu.get() << endl;//取消该语句注释后运行会报错，因为future对象的get()方法只能调用一次。
     return 0;
    }

**注意：future对象的get()方法只能调用一次。**

**3.2shared\_future**

std::future与std::shard\_future的用途都是为了**占位**，但是两者有些许差别。std::future的get()成员函数是转移数据所有权;std::shared\_future的get()成员函数是复制数据。 因此： **future对象的get()只能调用一次**；无法实现多个线程等待同一个异步线程，一旦其中一个线程获取了异步线程的返回值，其他线程就无法再次获取。 **std::shared\_future对象的get()可以调用多次**；可以实现多个线程等待同一个异步线程，每个线程都可以获取异步线程的返回值。

### **4.原子类型atomic** ###

原子操作指“不可分割的操作”，也就是说这种操作状态要么是完成的，要么是没完成的，不存在“操作完成了一半”这种状况。互斥量的加锁一般是针对一个代码段，而原子操作针对的一般都是一个变量(操作变量时加锁防止他人干扰)。 std::atomic<>是一个模板类，使用该模板类实例化的对象，提供了一些保证原子性的成员函数来实现共享数据的常用操作。

可以这样理解： 在以前，定义了一个共享的变量(int i=0)，多个线程会用到这个变量，那么每次操作这个变量时，都需要lock加锁，操作完毕unlock解锁，以保证线程之间不会冲突；但是这样每次加锁解锁、加锁解锁就显得很麻烦，那怎么办呢？ 现在，实例化了一个类对象(std::atomic<int> I=0)来代替以前的那个变量（这里的对象I你就把它看作一个变量，看作对象反而难以理解了），每次操作这个对象时，就不用lock与unlock，这个对象自身就具有原子性（相当于加锁解锁操作不用你写代码实现，能自动加锁解锁了），以保证线程之间不会冲突。

提到std::atomic<>，你脑海里就想到一点就可以了：std::atomic<>用来定义一个自动加锁解锁的共享变量（“定义”“变量”用词在这里是不准确的，但是更加贴切它的实际功能），供多个线程访问而不发生冲突。

//原子类型的简单使用
    std::atomic<bool> b(true);
    b=false;
    
    std::atomic<int> c(3);
    c=4;

std::atomic<>对象提供了常见的原子操作（通过调用成员函数实现对数据的原子操作）： store是原子写操作，load是原子读操作。exchange是于两个数值进行交换的原子操作。 **即使使用了std::atomic<>，也要注意执行的操作是否支持原子性**，也就是说，你不要觉得用的是具有原子性的变量（准确说是对象）就可以为所欲为了，你对它进行的运算不支持原子性的话，也不能实现其原子效果。一般针对++，–，+=，-=，&=，|=，^=是支持的，这些原子操作是通过在std::atomic<>对象内部进行运算符重载实现的。