【如何利用c++RAII技术实现自动加解锁】

1. 思路

可以使用C++中的 RAII（资源获取即初始化）技术来实现自动加锁解锁。这意味着你可以创建一个包含加锁和解锁操作的类，并在其构造函数中加锁，在析构函数中解锁。这样，在该类的实例化对象超出作用域时，自动调用析构函数，实现自动解锁。

2.示例1

#include <iostream>
#include <mutex>

class MutexLockGuard {
public:
    explicit MutexLockGuard(std::mutex& mutex) : mutex_(mutex) {
        mutex_.lock();
    }

    ~MutexLockGuard() {
        mutex_.unlock();
    }

private:
    std::mutex& mutex_;
};

// 使用 MutexLockGuard 自动加锁解锁
void someFunction() {
    std::mutex myMutex;
    {
        MutexLockGuard lock(myMutex); // 在这个作用域中自动加锁
        // 执行需要保护的代码
        std::cout << "Protected code is executed." << std::endl;
    }
    // 在这个作用域结束时，MutexLockGuard 的析构函数会自动解锁
}

int main() {
    someFunction();
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

在这个例子中，MutexLockGuard 类用于自动加锁和解锁 std::mutex。当 MutexLockGuard 对象 lock 超出作用域时，它的析构函数会自动调用，解锁 std::mutex。

这种方法确保了锁的正确释放，即使在发生异常或者早期返回的情况下也能保证。

2. 示例2

泛化锁类型，可以使用C++的模板。这样可以使 MutexLockGuard 类在使用时能够与不同类型的锁一起工作，例如 std::mutex、std::recursive_mutex 或者其他自定义的锁类型。

下面是一个示例代码：

#include <iostream>
#include <mutex>

// 通用的锁类型模板
template<typename LockType>
class LockGuard {
public:
    explicit LockGuard(LockType& lock) : lock_(lock) {
        lock_.lock();
    }

    ~LockGuard() {
        lock_.unlock();
    }

private:
    LockType& lock_;
};

// 使用 LockGuard 泛化锁类型
void someFunction() {
    std::mutex myMutex;
    {
        LockGuard<std::mutex> lock(myMutex); // 在这个作用域中自动加锁
        // 执行需要保护的代码
        std::cout << "Protected code is executed." << std::endl;
    }
    // 在这个作用域结束时，LockGuard 的析构函数会自动解锁
}

int main() {
    someFunction();
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

在这个示例中，LockGuard 类是一个模板类，可以接受任何类型的锁作为模板参数。这使得它可以与 std::mutex 以及其他类型的锁一起使用，从而实现对不同类型锁的自动加锁解锁。