简介： CSDN博客专家，专注Android/Linux系统，分享多mic语音方案、音视频、编解码等技术，与大家一起成长！
优质专栏：Audio工程师进阶系列【原创干货持续更新中……】🚀
人生格言： 人生从来没有捷径，只有行动才是治疗恐惧和懒惰的唯一良药.
1.前言
本篇目的：C++之互斥锁、读写锁、互斥量、 信号量、原子锁机制用法.
互斥锁、读写锁、互斥量、信号量和原子锁都是并发编程中常用的同步机制。
-
互斥锁（Mutex Lock）是最常见的同步机制之一，它用于保护共享资源，只允许一个线程访问资源，其他线程需要等待。互斥锁有两种状态：加锁和解锁。当一个线程获得了互斥锁并执行代码时，其他线程会被阻塞，直到锁被释放。通过互斥锁可以避免多个线程同时访问共享资源而导致的数据竞争问题。
-
读写锁（Read-Write Lock）允许多个线程同时读取共享资源，但只有一个线程可以写入资源。读写锁在读取操作频繁、写入操作较少的场景下可以提高并发性能。当有线程正在写入资源时，其他线程无法读取或写入资源，读写锁会保持写锁的状态，直到写操作完成。
-
互斥量（Mutex）和互斥锁类似，也用于保护共享资源。互斥量是一种更通用的同步机制，可以实现更复杂的同步逻辑。与互斥锁不同的是，互斥量可以由多个线程共享。
-
信号量（Semaphore）是一种计数器，用于控制对共享资源的访问。它可以控制同时访问资源的线程数量，并提供了同步和互斥的机制。信号量有两种操作：P操作（等待）和V操作（释放）。当信号量的计数器为0时，执行P操作的线程会被阻塞，直到计数器大于0时才能继续执行。
-
原子锁（Atomic Lock）是一种基于原子操作的同步机制，用于保护对共享资源的访问。原子操作是指不会被其他线程中断的操作。原子锁能够确保在同一时刻只有一个线程可以执行临界区代码，从而避免了竞态条件的发生。
2.应用实例
<1>. 互斥锁（Mutex Lock）的作用是保护共享资源，确保在同一时间只有一个线程可以访问该资源。
#include <iostream>
#include <mutex>
std::mutex mtx;
void sharedResourceAccess() {
// 锁定互斥锁，确保只有一个线程可以进入临界区
mtx.lock();
// 访问共享资源的代码
// ...
// 解锁互斥锁，允许其他线程访问共享资源
mtx.unlock();
}
int main() {
// 创建多个线程并发访问共享资源
// ...
return 0;
}
<2>. 读写锁（Read-Write Lock）的作用是允许多个线程同时读取共享资源，但只有一个线程可以写入资源。
#include <iostream>
#include <shared_mutex>
std::shared_mutex rwMutex;
void readAccess() {
// 读操作，可以同时由多个线程进入临界区
std::shared_lock<std::shared_mutex> readLock(rwMutex);
// 读取共享资源的代码
// ...
}
void writeAccess() {
// 写操作，只有一个线程可以进入临界区
std::unique_lock<std::shared_mutex> writeLock(rwMutex);
// 写入共享资源的代码
// ...
}
int main() {
// 创建多个线程并发读写共享资源
// ...
return 0;
}
<3>. 互斥量（Mutex）的作用与互斥锁类似，也用于保护共享资源。互斥量可以由多个线程共享，其用法与互斥锁类似。
#include <iostream>
#include <mutex>
std::mutex mtx;
void sharedResourceAccess() {
// 锁定互斥量，确保只有一个线程可以进入临界区
std::lock_guard<std::mutex> lock(mtx);
// 访问共享资源的代码
// ...
}
int main() {
// 创建多个线程并发访问共享资源
// ...
return 0;
}
<4>. 信号量（Semaphore）的作用是控制对共享资源的访问，限制同时访问资源的线程数量。
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
std::mutex mtx;
std::condition_variable cv;
int counter = 0;
void accessResource() {
std::unique_lock<std::mutex> lock(mtx);
// 等待信号量，当 counter 大于 0 时继续执行
cv.wait(lock, [] { return counter > 0; });
// 访问共享资源的代码
// ...
// 释放信号量，计数器减一
counter--;
}
void releaseResource() {
std::unique_lock<std::mutex> lock(mtx);
// 增加信号量，计数器加一
counter++;
// 通知等待的线程可以继续执行
cv.notify_one();
}
int main() {
// 创建多个线程并发访问共享资源
// ...
return 0;
}
<5>.原子锁，用于保护对共享资源的访问，原子操作是指不会被其他线程中断的操作。
#include <iostream>
#include <atomic>
#include <thread>
// 创建一个原子锁
std::atomic<bool> atomic_lock(false);
void criticalSection() {
while (atomic_lock.exchange(true)) {
// 原子锁正在被其他线程使用，等待...
}
// 进入临界区，访问共享资源
std::cout << "进入临界区，访问共享资源" << std::endl;
// 模拟一段临界区代码
std::this_thread::sleep_for(std::chrono::seconds(2));
// 退出临界区，释放原子锁
atomic_lock.store(false);
std::cout << "退出临界区，释放原子锁" << std::endl;
}
int main() {
// 创建多个线程并发访问临界区
std::thread t1(criticalSection);
std::thread t2(criticalSection);
// 等待线程完成
t1.join();
t2.join();
return 0;
}
3.自定义实现Mutex自动加锁和解锁
#include <iostream>
#include <mutex>
class Mutex {
public:
void lock() {
// 实现互斥锁的加锁操作
std::cout << "Mutex locked" << std::endl;
}
void unlock() {
// 实现互斥锁的解锁操作
std::cout << "Mutex unlocked" << std::endl;
}
};
class Autolock {
public:
explicit Autolock(Mutex& mutex) : mLock(mutex) {
mLock.lock();
}
~Autolock() {
mLock.unlock();
}
private:
Mutex& mLock;
};
int main() {
Mutex mutex;
{
Autolock autolock(mutex); // 创建Autolock对象，自动加锁
// 执行在临界区内的操作
std::cout << "In critical section" << std::endl;
} // Autolock对象销毁，自动解锁
return 0;
}
```
`注意：使用构造函数和析构函数实现Mutex自动加锁和解锁。`
