自动锁

使用pthread实现自动锁:

#include "pthread.h"

class Mutex
{
public:
	Mutex(void);
	virtual ~Mutex(void);

public:
	void lock();
	void unLock();
protected:
	pthread_mutex_t m_pMutex;
};


class AutoLock
{
public:
	AutoLock(Mutex &mutex);
	~AutoLock();
protected:
	Mutex& mMutex;
};


#include "Mutex.h"

Mutex::Mutex(void)
{
	pthread_mutexattr_t attr;
	pthread_mutexattr_init(&attr);
	pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
	pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
	pthread_mutex_init(&m_pMutex, &attr);
	pthread_mutexattr_destroy(&attr);
}

Mutex::~Mutex(void)
{
	pthread_mutex_destroy(&m_pMutex);
}

void Mutex::lock()
{
	(void)pthread_mutex_lock(&m_pMutex);
}

void Mutex::unLock()
{
	(void)pthread_mutex_unlock(&m_pMutex);
}

AutoLock::AutoLock(Mutex &mutex):mMutex(mutex)
{
	mMutex.lock();
}

AutoLock::~AutoLock()
{
	mMutex.unLock();
}


### 智能自动机制 C++ 中的智能利用 **RAII(Resource Acquisition Is Initialization)** 机制,在对象的生命周期内管理的获取和释放。其核心思想是将的获取绑定到对象的构造,将的释放绑定到对象的析构。当智能对象超出其作用域时,析构函数会自动调用,从而释放资源,确保即使在异常情况下也不会遗漏解操作[^1]。 ### 智能的实现方式 智能通常以模板类的形式实现,支持多种类型,例如 `std::mutex`、`std::recursive_mutex` 等。通过将对象以引用形式保存在智能类的成员变量中,确保在构造时加、析构时解作用于同一个对象[^1]。 以下是一个自定义智能类的实现示例: ```cpp #include <iostream> #include <mutex> #include <thread> template <class T> class SmartLock { public: explicit SmartLock(T& lock) : _lock(lock) { _lock.lock(); } ~SmartLock() { std::cout << "unlock: " << &_lock << std::endl; _lock.unlock(); } private: T& _lock; // 使用引用确保对象一致 }; std::mutex mtx; int shared_value = 0; void increment(int n) { SmartLock<std::mutex> lock(mtx); // 构造时加 for (int i = 0; i < n; ++i) { ++shared_value; } } // 析构时自动 int main() { std::thread t1(increment, 10000); std::thread t2(increment, 10000); t1.join(); t2.join(); std::cout << "Final value: " << shared_value << std::endl; return 0; } ``` 在上述代码中,`SmartLock` 类模板在构造时调用 `lock()`,在析构时调用 `unlock()`。当 `increment` 函数执行完毕,`lock` 对象超出作用域,析构函数被调用,自动释放。 ### 标准库中的智能实现 C++ 标准库提供了两个常用的智能实现: - **`std::lock_guard`**:轻量级管理类,仅在构造时加,析构时解,不支持延迟加或尝试加操作。 - **`std::unique_lock`**:功能更丰富的管理类,支持延迟加、尝试加、超时加等高级特性,同时仍遵循 RAII 原则。 两者均通过析构函数确保的正确释放,适用于不同的并发控制场景。 ### 生命周期与释放的绑定 智能对象通常在函数作用域内声明,其生命周期由编译器自动管理。当线程执行流离开该作用域时(无论是正常退出还是抛出异常),析构函数都会被调用,资源随之释放。这种机制避免了手动调用 `unlock()` 的遗漏问题,显著降低了死发生的概率[^1]。 ### 相关问题 1. 如何在 C++ 中实现自定义的智能? 2. `std::lock_guard` 和 `std::unique_lock` 之间有什么区别? 3. 智能在多线程编程中有哪些常见应用场景?
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值