协程库-锁类-实现线程互斥同步

mutex.h：信号量，互斥锁，读写锁，范围锁模板，自旋锁，原子锁

锁

**锁不能进行拷贝操作：**锁是用于管理多线程并发访问共享资源的同步原语。这些锁包括互斥锁（mutex）、读写锁（rwlock）等。它们通常不支持拷贝构造和拷贝赋值，这是为了防止在一个线程持有锁的情况下，另一个线程通过拷贝得到相同的锁，从而可能导致死锁或数据不一致的问题。

《Effective C++》条款 06

想要禁止⼀个类对象的拷⻉操作，就要禁⽌拷⻉构造函数和拷⻉赋值运算符。
解决⽅案2：
定义⼀个基类专⻔阻⽌拷⻉动作，继承该基类的派生类起实例化对象也就无法进行拷⻉操作。

/*** @file noncopyable.h* @brief 不可拷贝对象封装*/
#ifndef __Fzk_NONCOPYABLE_H__
#define __Fzk_NONCOPYABLE_H__
namespace FzkCoroutine {
/*** @brief 对象无法拷贝,赋值*/
class Noncopyable {
public:/*** @brief 默认构造函数*/Noncopyable() = default;/*** @brief 默认析构函数*/~Noncopyable() = default;/*** @brief 拷贝构造函数(禁用)*/Noncopyable(const Noncopyable&) = delete;/*** @brief 赋值函数(禁用)*/Noncopyable& operator=(const Noncopyable&) = delete;
};
}
#endif

基于pthread进一步封装了信号量，互斥锁，读写锁，范围锁模板，自旋锁，原子锁。

局部锁模板：

采用RAII编程风格，RAII的核心思想是利用对象的生命周期来管理资源，确保资源在对象的构造函数中被获取，并在析构函数中被释放。
ScopedLockImpl 及其派生类通过在构造时获取资源（加锁）并在析构时释放资源（解锁）。

/*** @brief 局部锁的模板实现*/
template<class T>
struct ScopedLockImpl {
public:/*** @brief 构造函数* @param[in] mutex Mutex*/ScopedLockImpl(T& mutex):m_mutex(mutex) {m_mutex.lock();m_locked = true;}/*** @brief 析构函数,自动释放锁*/~ScopedLockImpl() {unlock();}/*** @brief 加锁*/void lock() {if(!m_locked) {m_mutex.lock();m_locked = true;}}/*** @brief 解锁*/void unlock() {if(m_locked) {m_mutex.unlock();m_locked = false;}}
private:/// mutexT& m_mutex;/// 是否已上锁bool m_locked;
};

类似于C++的lock_guard：

lock_guard通过与互斥锁（mutex）结合使用来实现线程同步。当创建一个lock_guard对象时，获取提供给它的互斥锁的所有权，并自动调用互斥锁的lock()方法来加锁。如果互斥锁已经被其他线程锁定，当前线程将会阻塞，直到互斥锁被解锁。
当lock_guard对象离开作用域时，它的析构函数会被自动调用。在析构函数中，lock_guard会调用互斥锁的unlock()方法来解锁互斥锁。这样可以确保即使在异常情况下，互斥锁也能被正确解锁，避免死锁的发生。
lock_guard特点：
1、创建即加锁，作⽤域结束⾃动析构并解锁，⽆需⼿⼯解锁
2、不能中途解锁，必须等作⽤域结束才解锁
3、不能复制

#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx; // 定义一个互斥锁
int counter = 0; // 共享资源void increment() {for (int i = 0; i < 100000; ++i) {std::lock_guard<std::mutex> lock(mtx); // 加锁++counter; // 访问共享资源}
}
int main() {std::thread t1(increment);std::thread t2(increment);t1.join();t2.join();std::cout << "Counter: " << counter << std::endl;return 0;
}

互斥量Mutex：

/*** @brief 互斥量*/
class Mutex : Noncopyable { //继承不可拷贝数据类
public: /// 局部锁typedef ScopedLockImpl<Mutex> Lock;/*** @brief 构造函数*/Mutex() {pthread_mutex_init(&m_mutex, nullptr);}/*** @brief 析构函数*/~Mutex() {pthread_mutex_destroy(&m_mutex);}/*** @brief 加锁*/void lock() {pthread_mutex_lock(&m_mutex);}/*** @brief 解锁*/void unlock() {pthread_mutex_unlock(&m_mutex);}
private:/// mutexpthread_mutex_t m_mutex;
};

读写互斥量RWMutex：

/*** @brief 读写互斥量*/
class RWMutex : Noncopyable{
public:/// 局部读锁typedef ReadScopedLockImpl<RWMutex> ReadLock;/// 局部写锁typedef WriteScopedLockImpl<RWMutex> WriteLock;/*** @brief 构造函数*/RWMutex() {pthread_rwlock_init(&m_lock, nullptr);}/*** @brief 析构函数*/~RWMutex() {pthread_rwlock_destroy(&m_lock);}/*** @brief 上读锁*/void rdlock() {pthread_rwlock_rdlock(&m_lock);}/*** @brief 上写锁*/void wrlock() {pthread_rwlock_wrlock(&m_lock);}/*** @brief 解锁*/void unlock() {pthread_rwlock_unlock(&m_lock);}
private:/// 读写锁pthread_rwlock_t m_lock;
};

自旋锁

自旋锁是一种同步机制，它不会导致线程进入睡眠状态，而是通过循环不断尝试获取锁资源，可以避免线程切换的开销。但只适用于锁被持有时间短的场景，自旋等待的时间不会太长，而且可以避免线程切换的开销。如果锁被持有时间较长或竞争激烈导致很多线程在自旋等待，那么自旋锁可能会导致CPU资源的浪费，因为线程在等待时会持续占用CPU周期。
此外，自旋锁不适合在中断处理中使用，因为中断处理程序应该尽快完成，避免长时间占用CPU。

/*** @brief 自旋锁*/
class Spinlock : Noncopyable {
public:/// 局部锁typedef ScopedLockImpl<Spinlock> Lock;/*** @brief 构造函数*/Spinlock() {pthread_spin_init(&m_mutex, 0);}/*** @brief 析构函数*/~Spinlock() {pthread_spin_destroy(&m_mutex);}/*** @brief 上锁*/void lock() {pthread_spin_lock(&m_mutex);}/*** @brief 解锁*/void unlock() {pthread_spin_unlock(&m_mutex);}
private:/// 自旋锁pthread_spinlock_t m_mutex;
};

原子锁？？感觉就是用原子布尔类型实现的自旋锁

CASLock使用C++11中的std::atomic_flag来实现无锁同步，lock()函数使用std::atomic_flag_test_and_set_explicit()函数尝试获取锁，如果获取失败则一直循环等待。unlock()函数使用std::atomic_flag_clear_explicit()函数释放锁。
定义了一个volatile std::atomic_flag类型的成员变量m_mutex，用于表示锁的状态。由于它是volatile类型的，因此编译器不会对其进行优化，保证了其可见性，每次操作都会从内存读取m_mutex的值。

/*** @brief 原子锁*/
class CASLock : Noncopyable {
public:/// 局部锁typedef ScopedLockImpl<CASLock> Lock;/*** @brief 构造函数*/CASLock() {m_mutex.clear();}/*** @brief 析构函数*/~CASLock() {}/*** @brief 上锁*/void lock() {//获取失败则一直循环等待  感觉和自旋锁没区别了while (std::atomic_flag_test_and_set_explicit(&m_mutex, std::memory_order_acquire));}/*** @brief 解锁*/void unlock() {std::atomic_flag_clear_explicit(&m_mutex, std::memory_order_release);}
private:/// 原子状态volatile std::atomic_flag m_mutex;
};CASLock lock;
int shared_data = 0;void thread_func() {for (int i = 0; i < 100000; ++i) {CASLock::Lock l(lock); // 加锁++shared_data; // 访问共享资源}
}int test2() {std::thread t1(thread_func);std::thread t2(thread_func);t1.join();t2.join();std::cout << "shared_data: " << shared_data << std::endl;return 0;
}

测试效果：
1、加原子锁

2、未加原子锁

#include 只能将基本数据类型声明为原子变量

#include<iostream>
#include<thread>
#include<windows.h>
#include<atomic>     //新增
#include<vector>
#include<mutex>        
using namespace std;
void Mythread(atomic<int>& num)    //修改
{for (int i = 0; i < 100000; i++){		num++;	}
}
void test03()
{//int num = 0;std::atomic<int> num = 0;int threadNum = 2;     //线程个数vector<std::thread> m_thread;m_thread = vector<std::thread>(threadNum);for (auto i = 0; i < threadNum; i++){m_thread[i] = std::thread(Mythread, &num);}for (auto i = 0; i < threadNum; i++){m_thread[i].join();}cout <<"结果:"<<num << endl;
}
int main()
{test03();system("pause");return 0;
}

小结一下：

互斥量（Mutex）：
互斥量是最基本的同步机制之一。它阻止多个线程同时访问共享资源。
当一个线程锁定互斥量时，如果另一个线程尝试锁定同一个互斥量，它将被阻塞（挂起），直到拥有锁的线程释放该锁。
互斥量适用于锁定时间较长的场景，比如复杂操作或涉及I/O的操作。
在 C++ 中，可以使用头文件中的 std::mutex 类。
自旋锁（Spinlock）：
自旋锁在等待锁释放时，线程会在循环检查锁的状态直到获取锁，它不会使线程挂起，而是占用CPU周期等待。
自旋锁适用于锁定时间非常短的场景，因为它避免了线程挂起和恢复的开销（避免线程切换）。
C++11 标准没有直接提供自旋锁，但可以通过原子操作实现，或者使用平台特定的实现（如 POSIX 的 pthread_spinlock，POSIX“可移植操作系统接口”，能够在多种系统之间使用）。
原子锁（Atomic Lock）：
原子操作是指不可分割、不会被线程调度机制打断的操作。在执行完毕之前，不会有其他线程对这个操作进行干扰。
C++11 引入了原子操作库，提供了一组原子类型，如 std::atomic，可以用来实现低开销的线程安全操作。
原子操作通常用于简单的赋值、递增、递减等操作，而且是无锁的，所以开销比互斥量和自旋锁都要小。
总结：
使用互斥量时，长时间锁定资源会使其他线程挂起，适合复杂操作。
使用自旋锁时，线程会忙等待直到获取锁，适合短时间锁定资源。
使用原子操作时，可以保证单一操作的线程安全，无需锁定，开销最小，但仅限于简单操作（因为只有两种状态）。