std::mutex
mutex代表的是MUTual EXclusive（禁止同时访问），通过memory barrier来实现。不同平台实现不一样，这里不深究了。
线程安全队列
#include <mutex>
#include <queue>
class threadSafe_queue {
std::queue<int> rawQueue; // shared structure between all threads
std::mutex m; // rawQueue's red door
public:
int& retrieve_and_delete() {
int front_value = 0; // if empty return 0
m.lock();
// From now on, the current thread is the only one that can access rawQueue
if( !rawQueue.empty() ) {
front_value = rawQueue.front();
rawQueue.pop();
}
m.unlock();
// other threads can lock the mutex now
return front_value;
};
void push(int val) {
m.lock();
rawQueue.push(val);
m.unlock();
};
};
使用std::lock_guard，不需要主动unlock了
#include <mutex>
#include <queue>
class threadSafe_queue {
std::queue<int> rawQueue; // shared structure between all threads
std::mutex m; // rawQueue's red door
public:
int& retrieve_and_delete() {
int front_value = 0; // if empty return 0
std::lock_guard<std::mutex> lg(m);
// From now on, the current thread is the only one that can access rawQueue
if( !rawQueue.empty() ) {
front_value = rawQueue.front();
rawQueue.pop();
}
return front_value;
}; // other threads can lock the mutex now
void push(int val) {
std::lock_guard<std::mutex> lg(m);
// from now on, the current thread is the only one that can access rawQueue
rawQueue.push(val);
}; // other threads can lock the mutex now
};
std::unique_lock可以通过unlock来解锁，同时不是去raii的优势
std::vector< int > vector; // shared between threads
std::mutex mutex;
...
int function(...)
{
...
std::unique_lock guard(mutex);
Getting int from the shared vector.
...
...
guard.unlock();
Long, complicated computation with int.
This part does not depend on the vector.
...
}
[c++17]std::shared_mutex,std::shared_lock,std::unique_lock
#include <shared_mutex>
#include <vector>
std::shared_mutex door; //mutex declaration
std::vector<int> v;
int readVectorSize() {
/* multiple threads can call this function simultaneously
* no writing access allowed when sl is acquired */
std::shared_lock<std::shared_mutex> sl(door);
return v.size();
}
void pushElement(int new_element) {
/* exclusive access to vector guaranteed */
std::unique_lock<std::shared_mutex> ul(door);
v.push_back(new_element);
}
std::scoped_lock支持同时锁住多个互斥量
c++11
void deadLock(CriticalData& a, CriticalData& b){
std::unique_lock<mutex> guard1(a.mut, std::defer_lock);
std::unique_lock<mutex> guard2(b.mut, std::defer_lock);
std::lock(guard1, guard2);
// do something with a and b (critical region)
}
c++17
void deadLock(CriticalData& a, CriticalData& b){
std::scoped_lock(a.mut, b.mut);
// do something with a and b (critical region
}
