一.互斥锁
多个线程访问同一资源时,为了保证数据的一致性,最简单的方式就是使用 mutex(互斥锁)。
引用 cppreference 的介绍:
The mutex class is a synchronization primitive that can be used to protect shared data from being simultaneously accessed by multiple threads.
#include <iostream>
#include <mutex>
#include <thread>
#include <vector>
std::mutex g_mutex;
int g_count = 0;
void Counter() {
g_mutex.lock();
int i = ++g_count;
std::cout << "count: " << i << std::endl;
// 前面代码如有异常,unlock 就调不到了。
g_mutex.unlock();
}
int main() {
const std::size_t SIZE = 4;
// 创建一组线程。
std::vector<std::thread> v;
v.reserve(SIZE);
for (std::size_t i = 0; i < SIZE; ++i) {
v.emplace_back(&Counter);
}
// 等待所有线程结束。
for (std::thread& t : v) {
t.join();
}
return 0;
}
二.递归锁
在一些业务场景下,线程在获取锁后还会多次获取该锁,且保证不出现死锁或者程序崩溃异常。简单地说,递归锁是一种在锁已被持有的情况下,允许同一线程对该锁进行多次加锁的机制,也叫可重入锁。
举个例子,一个递归函数,需要被一个线程多次调用,且当前函数中某些临界区需要加锁,如果我们使用常规的mutex等锁进行多次lock(),必然会导致程序异常,此时如果使用递归锁,那么将允许我们多次lock()。有些需要加锁的业务方法,在进行一些业务组合的时候,可能会被调用多次,如果使用常规锁,可能会死锁,比如上一次的加锁还没有解锁,第二次调用的地方又进行加锁,导致死锁,导致程序执行不下去。原因在于,递归锁中会记录加锁的次数,每次加锁,计数+1,且判断如果已经锁住,不做处理,每次解锁,计数-1,所以使用时需要我们做好对等解锁操作。
std::recursive_mutex rmtx;
void TaskOne()
{
rmtx.lock();
std::cout << "Task One" << std::endl;
rmtx.unlock();
}
void TaskTwo()
{
rmtx.lock();
std::cout << "Task Two" << std::endl;
rmtx.unlock();
}
void ThradFunc()
{
while (true)
{
rmtx.lock();
TaskOne();
std::cout << "thread_id = " << std::this_thread::get_id() << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(200));
TaskTwo();
rmtx.unlock();
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
}
int main()
{
for(int i = 0; i < 3; ++i)
{
std::thread t(ThradFunc);
t.detach();
}
getchar();
return 0;
}
三.超时锁
超时锁:用来记录线程加锁 解锁 等竞争锁的过程,多用于调试多线程时使用。启动多个线程,然后,竞争一把超时锁,分别打印记录加锁成功的线程和失败的线程id:
std::timed_mutex tmtx;
void ThradFunc()
{
while (true)
{
if(!tmtx.try_lock_for(std::chrono::milliseconds(100)))
{
std::cout << "thread_id = " << std::this_thread::get_id() << " try lock failed" << std::endl;
continue;
}
std::cout << "thread_id = " << std::this_thread::get_id() << " try lock success" << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(200));
tmtx.unlock();
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
}
int main()
{
for(int i = 0; i < 3; ++i)
{
std::thread t(ThradFunc);
t.detach();
}
getchar();
return 0;
}
四.共享锁(读写锁)
相比互斥锁,读写锁允许更高的并行性。读写锁可以有三种状态:
- 读模式加锁状态;
- 写模式加锁状态;
- 不加锁状态;
只有一个线程可以占有写模式的读写锁,但是可以有多个线程占有读模式的读写锁。读写锁也叫做“共享-独占锁”,当读写锁以读模式锁住时,它是以共享模式锁住的;当它以写模式锁住时,它是以独占模式锁住的。
- 当读写锁处于写加锁状态时,在其解锁之前,所有尝试对其加锁的线程都会被阻塞;
- 当读写锁处于读加锁状态时,所有试图以读模式对其加锁的线程都可以得到访问权,但是如果想以写模式对其加锁,线程将阻塞。这样也有问题,如果读者很多,那么写者将会长时间等待,如果有线程尝试以写模式加锁,那么后续的读线程将会被阻塞,这样可以避免锁长期被读者占有。
shared_mutex (c++17)类是一个同步原语,可用于保护共享数据不被多个线程同时访问。与便于独占访问的其他互斥类型不同,shared_mutex 拥有二个访问级别:共享 - 多个线程能共享同一互斥的所有权;独占性 - 仅一个线程能占有互斥。
- 若一个线程已经通过lock或try_lock获取独占锁(写锁),则无其他线程能获取该锁(包括共享的)。尝试获得读锁的线程也会被阻塞。
- 仅当任何线程均未获取独占性锁时,共享锁(读锁)才能被多个线程获取(通过 lock_shared 、try_lock_shared )。
- 在一个线程内,同一时刻只能获取一个锁(共享或独占性)。
成员函数主要包含两大类:排他性锁定(写锁)和共享锁定(读锁)
#include <iostream>
#include <mutex> //unique_lock
#include <shared_mutex> //shared_mutex shared_lock
#include <thread>
std::mutex mtx;
class ThreadSaferCounter
{
private:
mutable std::shared_mutex mutex_;
unsigned int value_ = 0;
public:
ThreadSaferCounter(/* args */) {};
~ThreadSaferCounter() {};
unsigned int get() const {
//读者, 获取共享锁, 使用shared_lock
std::shared_lock<std::shared_mutex> lck(mutex_);//执行mutex_.lock_shared();
return value_; //lck 析构, 执行mutex_.unlock_shared();
}
unsigned int increment() {
//写者, 获取独占锁, 使用unique_lock
std::unique_lock<std::shared_mutex> lck(mutex_);//执行mutex_.lock();
value_++; //lck 析构, 执行mutex_.unlock();
return value_;
}
void reset() {
//写者, 获取独占锁, 使用unique_lock
std::unique_lock<std::shared_mutex> lck(mutex_);//执行mutex_.lock();
value_ = 0; //lck 析构, 执行mutex_.unlock();
}
};
ThreadSaferCounter counter;
void reader(int id){
while (true)
{
std::this_thread::sleep_for(std::chrono::seconds(1));
std::unique_lock<std::mutex> ulck(mtx);//cout也需要锁去保护, 否则输出乱序
std::cout << "reader #" << id << " get value " << counter.get() << "\n";
}
}
void writer(int id){
while (true)
{
std::this_thread::sleep_for(std::chrono::seconds(1));
std::unique_lock<std::mutex> ulck(mtx);//cout也需要锁去保护, 否则输出乱序
std::cout << "writer #" << id << " write value " << counter.increment() << "\n";
}
}
int main()
{
std::thread rth[10];
std::thread wth[10];
for(int i=0; i<10; i++){
rth[i] = std::thread(reader, i+1);
}
for(int i=0; i<10; i++){
wth[i] = std::thread(writer, i+1);
}
for(int i=0; i<10; i++){
rth[i].join();
}
for(int i=0; i<10; i++){
wth[i].join();
}
return 0;
}
五.RAII管理锁定与释放
RAII,全称资源获取即初始化(英语:Resource Acquisition Is Initialization),它是在一些面向对象语言中的一种惯用法。RAII源于C++,在Java,C#,D,Ada,Vala和Rust中也有应用。1984-1989年期间,比雅尼·斯特劳斯特鲁普和安德鲁·柯尼希在设计C++异常时,为解决资源管理时的异常安全性而使用了该用法[1],后来比雅尼·斯特劳斯特鲁普将其称为RAII[2]。
RAII要求,资源的有效期与持有资源的对象的生命期严格绑定,即由对象的构造函数完成资源的分配(获取),同时由析构函数完成资源的释放。在这种要求下,只要对象能正确地析构,就不会出现资源泄漏问题。
#include <iostream>
#include <mutex>
#include <thread>
#include <vector>
//RAII管理锁
template<typename _MUTEX_CLASS>
class XMutex{
public:
explicit XMutex(_MUTEX_CLASS & mutex_) : Mutex_(mutex_){
//申请资源即初始化
mutex_.lock();
}
~XMutex(){
Mutex_.unlock();
std::cout << "Unlock" << std::endl;
}
private:
_MUTEX_CLASS &Mutex_;
};
std::mutex mux;
void Th_fun(){
XMutex X(mux);
std::cout << "Lock" << std::endl;
}
int main() {
std::thread t(Th_fun);
t.join();
return 0;
}