C++11多线程互斥锁mutex,unique_lock,lock_guard
互斥锁
互斥锁是线程中常用的线程同步手段, 在C++11后使用互斥互斥锁的方式包括两种pthread_mutex_t和std::mutex
pthread_mutex_t
这是Linux下pthread的锁, 介绍
std::mutex
我们这里介绍一下C++11中
std::mutex的基本使用
头文件: #include<mutex>
成员函数:
- 构造函数,
std::mutex _mutex;不必传入参数, 不允许拷贝构造和move构造 -
lock(): 上锁, 如果其他线程已经持有锁的话会一直阻塞 -
unlock(): 解锁 -
try_lock(): 与lock相同用于加锁, 如果其他线程持有锁的话立刻返回false
扩展
事实上还存在有其他类型的锁, 比如:recursive_mutex和time_mutex这些锁个人基本没用到过, 可以实现递归加锁解锁/加锁超时的限制, 如果有需要自行了解
进阶版使用, unique_lock,lock_guard
对于以上的简单使用其实与C语言相差不大, 但是我们可以使用
RAII(通过类的构造析构)来实现更好的编码方式.
ps: C++相较于C引入了很多新的特性, 比如可以在代码中抛出异常, 如果还是按照以前的加锁解锁的话代码会极为复杂繁琐
代码:
#include <iostream> // std::cout
#include <thread> // std::thread
#include <mutex> // std::mutex, std::lock_guard
#include <stdexcept> // std::logic_error
std::mutex mtx;
void print_even (int x) {
if (x%2==0) std::cout << x << " is even\n";
else throw (std::logic_error("not even"));
}
void print_thread_id (int id) {
try {
// using a local lock_guard to lock mtx guarantees unlocking on destruction / exception:
std::lock_guard<std::mutex> lck (mtx);
print_even(id);
}
catch (std::logic_error&) {
std::cout << "[exception caught]\n";
}
}
int main ()
{
std::thread threads[10];
// spawn 10 threads:
for (int i=0; i<10; ++i)
threads[i] = std::thread(print_thread_id,i+1);
for (auto& th : threads) th.join();
return 0;
}
这里的lock_guard换成unique_lock也是一样的, 我并未深入研究内部实现; 但是可以很简单的猜到, 在构造函数中加锁,析构函数中解锁
unique_lock,lock_guard的区别
unique_lock与lock_guard都能实现自动加锁和解锁，但是前者更加灵活，能实现更多的功能。unique_lock可以进行临时解锁和再上锁，如在构造对象之后使用lck.unlock()就可以进行解锁，lck.lock()进行上锁，而不必等到析构时自动解锁。
unique_lock扩展条件变量
C++11提供
std::condition_variable可以和std::mutex配合使用, 不过往往是配合unique_lock进行使用, 所以在这里介绍一下
#include <iostream>
#include <deque>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <unistd.h>
std::deque<int> q;
std::mutex mu;
std::condition_variable cond;
void fun1() {
while (true) {
std::unique_lock<std::mutex> locker(mu);
q.push_front(count);
locker.unlock();
cond.notify_one();
sleep(10);
}
}
void fun2() {
while (true) {
std::unique_lock<std::mutex> locker(mu);
cond.wait(locker, [](){return !q.empty();});
data = q.back();
q.pop_back();
locker.unlock();
std::cout << "thread2 get value form thread1: " << data << std::endl;
}
}
int main() {
std::thread t1(fun1);
std::thread t2(fun2);
t1.join();
t2.join();
return 0;
}
条件变量的目的就是为了, 在没有获得某种提醒时长时间休眠; 如果正常情况下, 我们需要一直循环(+sleep), 这样的问题就是CPU消耗+时延问题, 条件变量的意思是在cond.wait这里一直休眠直到cond.notify_one唤醒才开始执行下一句; 还有cond.notify_all()接口用于唤醒所有等待的线程.
cond.wait(locker, {return !q.empty();});: 条件变量可能会被意外唤醒, 可以额外传入一个函数只有被唤醒时同时函数返回值为true才会被真正唤醒(也可以不传再外部判断)
那么为什么必须使用unique_lock呢?
原因: 条件变量在
wait时会进行unlock再进入休眠,lock_guard并无该操作接口
wait: 如果线程被唤醒或者超时那么会先进行lock获取锁, 再判断条件(传入的参数)是否成立, 如果成立则waut函数返回否则释放锁继续休眠
notify: 进行notify动作并不需要获取锁
