C++并发多线程--std::recursive_mutex和std::timed_mutex的使用

1--std::recursive_mutex的使用

        std::recursive_mutex 创建递归的独占互斥量，允许一个线程对其多次加锁和解锁；

#include <iostream>
#include <thread>
#include <list>
#include <mutex> // 引入互斥
 
class myClass{
public:
    // 收集数据到消息队列
    void inMsgRecvQueue(){
        for(int i = 0; i < 100; i++){
            // 模拟收集消息
            std::cout << "Running inMsgRecvQueue(), insert one value: " 
                << i << std::endl; 
            // 多次加锁和解锁
            my_mutex.lock();
            my_mutex.lock();
            msgRecvqueue.push_back(i); // 消息队列存储消息
            my_mutex.unlock();
            my_mutex.unlock();
        }
    }
    // 从消息队列取数据
    void outMsgRecvQueue(){
        for(int i = 0; i < 100; i++){
            if(!msgRecvqueue.empty()){
                // 多次加锁和解锁
                my_mutex.lock(); // 加锁
                my_mutex.lock(); // 加锁
                int command = msgRecvqueue.front();
                msgRecvqueue.pop_front(); 
                my_mutex.unlock(); // 解锁
                my_mutex.unlock(); // 解锁
            }
            
            else{
                std::cout << "Running outMsgRecvQueue(), " 
                    "the msgRecvqueue is empty" << std::endl;
            }
        }
    }
private:
    std::list<int> msgRecvqueue; // 消息队列
    std::recursive_mutex my_mutex; // 创建互斥量 
};
 
int main(int argc, char *argv[]){
    // std::recursive_mutex 创建递归的独占互斥量，允许一个线程对其多次加锁和解锁

    myClass sample1;
    std::thread myInMsgObj(&myClass::inMsgRecvQueue, &sample1); // 收集数据线程
    std::thread myOutMsgObj(&myClass::outMsgRecvQueue, &sample1); // 取出数据线程
    myInMsgObj.join();
    myOutMsgObj.join();
    return 0;
}

2--std::timed_mutex的使用

        std::timed_mutex 带有超时功能的独占互斥量，try_lock_for() 等待一段时间来尝试获取锁，若无法获取锁，则线程继续执行（跳过临界区的内容）；try_lock_until() 是直到某一时间内都在尝试获取锁，如果超过了规定的时间点仍无法获取锁，线程就会继续执行（跳过临界区的内容）；

#include <iostream>
#include <thread>
#include <list>
#include <mutex> // 引入互斥
 
class myClass{
public:
    // 收集数据到消息队列
    void inMsgRecvQueue(){
        for(int i = 0; i < 100; i++){
            std::chrono::seconds timeout(1);
            if(my_mutex.try_lock_for(timeout)){ // 等待1s来获取锁
            // if(my_mutex.try_lock_until(std::chrono::steady_clock::now() + timeout)){
                // 模拟收集消息
                std::cout << "Running inMsgRecvQueue(), insert one value: " 
                    << i << std::endl; 
                msgRecvqueue.push_back(i); // 消息队列存储消息
                my_mutex.unlock();
            }
            else{ // 获取不成功
                std::chrono::seconds sleeptime(1); // 线程休息1s
                std::this_thread::sleep_for(sleeptime);
                std::cout << "can not get the lock" << std::endl;
            }
        }
    }
    // 从消息队列取数据
    void outMsgRecvQueue(){
        for(int i = 0; i < 100; i++){
            if(!msgRecvqueue.empty()){
                my_mutex.lock(); // 加锁
                std::chrono::seconds sleeptime(3);
                std::this_thread::sleep_for(sleeptime);
                int command = msgRecvqueue.front();
                msgRecvqueue.pop_front(); 
                my_mutex.unlock(); // 解锁

            }
            else{
                std::cout << "Running outMsgRecvQueue(), " 
                    "the msgRecvqueue is empty" << std::endl;
            }
        }
    }
private:
    std::list<int> msgRecvqueue; // 消息队列
    std::timed_mutex my_mutex; // 创建互斥量 
};
 
int main(int argc, char *argv[]){
    // std::timed_mutex 带有超时功能的独占互斥量
    myClass sample1;
    std::thread myInMsgObj(&myClass::inMsgRecvQueue, &sample1); // 收集数据线程
    std::thread myOutMsgObj(&myClass::outMsgRecvQueue, &sample1); // 取出数据线程
    myInMsgObj.join();
    myOutMsgObj.join();
    return 0;
}