c++多线程面试必备之 - 如何保证线程的执行顺序

1.互斥量(mutex)

用代码把共享数据锁住，其他尝试操作共享数据的线程必须等待 锁定->操作->解锁

头文件#include<mutex>

lock()   unlock()是mutex的成员函数，成对使用，有lock必然要有unlock

using namespace std;
class A {
public:
    //收到数据，塞进容器中
    void inMsgRecList() {
        for (int i = 0;i < 100000;i++) {
            cout << "inMsgRecList插入一个元素" << i << endl;
            my_mutex.lock();
            msgRecList.push_back(i);
            my_mutex.unlock();
        }
    }
    //从容其中取出数据
    void outMsgRecList() {
        for (int i = 0;i < 100000;i++) {
            my_mutex.lock();
            if (!msgRecList.empty()) {
                int msg = msgRecList.front();
                msgRecList.pop_front();
                my_mutex.unlock();
            }
            else {
                cout << "outMsgRecList执行，但List中为空" << endl;
                my_mutex.unlock();
            }
        }
        cout << "执行完了" << endl;
    }
private:
    list<int> msgRecList;
    mutex my_mutex;
};

int main() {
    A myobj;
    thread myOutthread(&A::outMsgRecList,&myobj);
    thread myInthread(&A::inMsgRecList, &myobj);
    myOutthread.join();
    myInthread.join();
    
    return 0;
}

加了锁程序可以稳定运行不会再崩溃了，要记住if语句中每个分支都要unlock

unlock非常难排查所以引入了std::lock_guard类模板

lock_guard可以直接取代lock和unlock，使用lock_guard后不能使用lock和unlock了

mutex my_mutex;
lock_gurad<mutex> myLockGud(my_mutex);

void inMsgRecList() {
        for (int i = 0;i < 100000;i++) {
            cout << "inMsgRecList插入一个元素" << i << endl;
            lock_guard<mutex> myLockGuard(my_mutex);
            msgRecList.push_back(i);
        }
    }
    //从容其中取出数据
    void outMsgRecList() {
        for (int i = 0;i < 100000;i++) {
            lock_guard<mutex> myLockGuard(my_mutex);
            if (!msgRecList.empty()) {
                int msg = msgRecList.front();
                msgRecList.pop_front();
            }
            else {
                cout << "outMsgRecList执行，但List中为空" << endl;
            }
        }
        cout << "执行完了" << endl;
    }

lock_guard创建的时候调用构造函数lock，在函数执行结束前调用析构函数unlock，可以加上作用域使lock_guard提前析构

void inMsgRecList() {
        for (int i = 0;i < 100000;i++) {
            cout << "inMsgRecList插入一个元素" << i << endl;
            {
                lock_guard<mutex> myLockGuard(my_mutex);
                msgRecList.push_back(i);
            }
        }
    }
    //从容其中取出数据
    void outMsgRecList() {
        for (int i = 0;i < 100000;i++) {
            lock_guard<mutex> myLockGuard(my_mutex);
            if (!msgRecList.empty()) {
                int msg = msgRecList.front();
                msgRecList.pop_front();
            }
            else {
                cout << "outMsgRecList执行，但List中为空" << endl;
            }
        }
        cout << "执行完了" << endl;
    }

死锁

至少两个锁头(互斥量)才能产生死锁问题

using namespace std;
class A {
public:
    //收到数据，塞进容器中
    void inMsgRecList() {
        for (int i = 0;i < 100000;i++) {
            cout << "inMsgRecList插入一个元素" << i << endl;
            my_mutex1.lock();
            my_mutex2.lock();
            msgRecList.push_back(i);
            my_mutex1.unlock();
            my_mutex2.unlock();
        }
    }
    //从容其中取出数据
    void outMsgRecList() {
        for (int i = 0;i < 100000;i++) {
            my_mutex2.lock();
            my_mutex1.lock();
            if (!msgRecList.empty()) {
                int msg = msgRecList.front();
                msgRecList.pop_front();
                my_mutex1.unlock();
                my_mutex2.unlock();
            }
            else {
                cout << "outMsgRecList执行，但List中为空" << endl;
                my_mutex1.unlock();
                my_mutex2.unlock();
            }
        }
        cout << "执行完了" << endl;
    }
private:
    list<int> msgRecList;
    mutex my_mutex1;
    mutex my_mutex2;
};

int main() {
    A myobj;
    thread myOutthread(&A::outMsgRecList,&myobj);
    thread myInthread(&A::inMsgRecList, &myobj);
    myOutthread.join();
    myInthread.join();
    
    return 0;
}

解决死锁的办法

1.只要保证两个锁头的上锁顺序一致。

2.std::lock(mutex1,mutex2),

3.std::lock_guard<mutex> mylocgad(mutex1,std::adopt_lock);这个函数可以让lock_guard不执行构造函数，只执行析构函数，意思是可以手动lock，让lock_guard来帮助自动unlock，在lock的时候更加灵活了，在unlock的时候也更加方便了

class A {
public:
    //收到数据，塞进容器中
    void inMsgRecList() {
        for (int i = 0;i < 100000;i++) {
            cout << "inMsgRecList插入一个元素" << i << endl;
            std::lock(my_mutex1, my_mutex2);
            lock_guard<mutex> mylockguard1(my_mutex1,std::adopt_lock);
            lock_guard<mutex> mylockguard2(my_mutex2,std::adopt_lock);
            msgRecList.push_back(i);

        }
    }
    //从容其中取出数据
    void outMsgRecList() {
        for (int i = 0;i < 100000;i++) {
            std::lock(my_mutex1, my_mutex2);
            lock_guard<mutex> mylockguard1(my_mutex1, std::adopt_lock);
            lock_guard<mutex> mylockguard2(my_mutex2, std::adopt_lock);
            if (!msgRecList.empty()) {
                int msg = msgRecList.front();
                msgRecList.pop_front();
            }
            else {
                cout << "outMsgRecList执行，但List中为空" << endl;
            }
        }
        cout << "执行完了" << endl;
    }
private:
    list<int> msgRecList;
    mutex my_mutex1;
    mutex my_mutex2;
};

unique_lock

unique_lock比lock_guard灵活，但是效率第一点，内存占用高一点

unique_lock<mutex> my_unilock(my_mutex);

第一种使用方法与lock_guard没有区别

unique_lock第二个参数

std::adopt lock ，必须提前手动lock互斥量，不在此构造函数中lock

std::try_to_lock ，尝试去锁定互斥量，但如果没有锁定成功，会直接return不回阻塞。

unique_lock<mutex> myulock(my_mutex1,std::try_to_lock);
if(myulock.owns.lock()){
    //拿到了锁
    //可以操作全局数据
}else{
    //妹拿到锁，不能操作全局数据，但可以做点别的。
}

std::defer_lock

unique_lock<mutex> myulock(my_mutex1,std::try_to_lock);
//创建了一个my_mutex1的互斥量与myulock绑定，没有锁定，需要手动锁定
myulock.lock();