C++11 互斥量mutex----mutex/time_mutex/recursive_mutex/recursive_timed_mutex

互斥量

C++11提供如下4种语义的互斥量（mutex）

• std::mutex，独占的互斥量，不能递归使用。
• std::time_mutex，带超时的独占互斥量，不能递归使用。
• std::recursive_mutex，递归互斥量，不带超时功能。
• std::recursive_timed_mutex，带超时的递归互斥量。

std::mutex

介绍

std::mutex 是C++11 中最基本的互斥量，std::mutex 对象提供了独占所有权的特性——即不支持递归地对 std::mutex 对象上锁，而 std::recursive_lock 则可以递归地对互斥量对象上锁

成员函数

• 构造函数，std::mutex不允许拷贝构造，也不允许 move 拷贝，最初产生的 mutex 对象是处于unlocked 状态的。
• lock()，调用线程将锁住该互斥量。线程调用该函数会发生下面 3 种情况：
  • 如果该互斥量当前没有被锁住，则调用线程将该互斥量锁住，直到调用 unlock之前，该线程一直拥有该锁。
  • 如果当前互斥量被其他线程锁住，则当前的调用线程被阻塞住。
  • 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)。
• unlock()， 解锁，释放对互斥量的所有权。
• try_lock()，尝试锁住互斥量，如果互斥量被其他线程占有，则当前线程也不会被阻塞。线程调用该函数也会出现下面 3 种情况：
  • 如果当前互斥量没有被其他线程占有，则该线程锁住互斥量，直到该线程调用 unlock 释放互斥量。
  • 如果当前互斥量被其他线程锁住，则当前调用线程返回false，而并不会被阻塞掉。
  • 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)。

使用案例

#include  // std::cout
#include     // std::mutex
#include    // std::thread

volatile int counter(0); // non-atomic counter
std::mutex mtx;          // locks access to counter

void increases_10k() {
  for (int i = 0; i < 10000; ++i) {
    // 1. 使用try_lock的情况
    // if (mtx.try_lock()) {
    // only increase if currently not locked: // ++counter; // mtx.unlock(); //
    // } //
    // 2. 使用lock的情况
    {
      mtx.lock();
      ++counter;
      mtx.unlock();
    }
  }
}
int main() {
  std::thread threads[10];
  for (int i = 0; i < 10; ++i)
    threads[i] = std::thread(increases_10k);
  for (auto &th : threads)
    th.join();
  std::cout << " successful increases of the counter " << counter <<
  std::endl; return 0;
}

std::recursive_mutex

介绍

递归锁允许同一个线程多次获取该互斥锁，可以用来解决同一线程需要多次获取互斥量时死锁的问题。

虽然递归锁能解决这种情况的死锁问题，但是尽量不要使用递归锁，主要原因如下：

• 需要用到递归锁的多线程互斥处理本身就是可以简化的，允许递归很容易放纵复杂逻辑的产生，并且产生晦涩，当要使用递归锁的时候应该重新审视自己的代码是否一定要使用递归锁；
• 递归锁比起非递归锁，效率会低；
• 递归锁虽然允许同一个线程多次获得同一个互斥量，但可重复获得的最大次数并未具体说明，一旦超过一定的次数，再对lock进行调用就会抛出std::system错误。

使用案例

不使用递归锁：

#include  
#include  
#include  

struct Complex {
	std::mutex mutex; 
	int i; 
	Complex() : i(0){} 
	void mul(int x) { 
		std::lock_guard<std::mutex> lock(mutex); 
		i *= x; 
	}
	boid both(int x, int y) { 
		std::lock_guard<std::mutex> lock(mutex); 
		mul(x); 
	} 
};
int main(void) { 
	Complex complex; 
	complex.both(32, 23); 
	return 0; 
}

会导致死锁，因为在both中已经上了锁，还未释放锁便在mul中再次申请了锁。
使用递归锁：

#include  
#include  
#include  
struct Complex { 
	std::recursive_mutex mutex; 
	int i; 
	Complex() : i(0){} 
	void mul(int x) { 
		std::lock_guard<std::recursive_mutex> lock(mutex); 
		i *= x;
	}
	void both(int x, int y) { 
		std::lock_guard<std::recursive_mutex> lock(mutex); 
		mul(x); 
	} 
};
int main(void) { 
	Complex complex; 
	complex.both(32, 23); //因为同一线程可以多次获取同一互斥量，不会发生死锁 
	std::cout << "main finish\n"; 
	return 0; 
}

std::timed_mutex和std::recursive_timed_mutex

#include  
#include  
#include  
#include  
std::timed_mutex mutex; 

void work() { 
	std::chrono::milliseconds timeout(100); 
	while (true) { 
		if (mutex.try_lock_for(timeout)){
			std::cout << std::this_thread::get_id() << ": do work with the mutex" << std::endl; 
			std::chrono::milliseconds sleepDuration(250);
			std::this_thread::sleep_for(sleepDuration); 
			mutex.unlock(); 
			std::this_thread::sleep_for(sleepDuration); 
		}else { 
			std::cout << std::this_thread::get_id() << ": do work without the mutex" << std::endl; 
			std::chrono::milliseconds sleepDuration(100); 	
			std::this_thread::sleep_for(sleepDuration); 
		} 
	} 
}
int main(void) { 
	std::thread t1(work); 
	std::thread t2(work); 
	t1.join(); 
	t2.join(); 
	std::cout << "main finish\n"; 
	return 0; 
}

都能获取到锁，一直打印“do work without the mutex”

lock_gurad/unique_lock

使用lock_gurad和unique_lock有利于遵守RAII的规范。

使用

#include  
#include  // std::thread 
#include  // std::mutex, std::lock_guard 
#include  // 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; 
}

区别

• unique_lock与lock_guard都能实现自动加锁和解锁，但是前者更加灵活，能实现更多的功能；但是也要付出更多的时间、性能成本。
• unique_lock可以进行临时解锁和再上锁，如在构造对象之后使用lck.unlock()就可以进行解锁，lck.lock()进行上锁，而不必等到析构时自动解锁。

#include  
#include  
#include  
#include  
#include  
#include  

std::deque<int> q; 
std::mutex mu; 
std::condition_variable cond; 
int count = 0; 

void fun1() { 
	while (true) { 
	// { 
		std::unique_lock<std::mutex> locker(mu); 
		q.push_front(count++); 
		locker.unlock();  // 手动解锁或者加大括号
		cond.notify_one(); 
	// } 
		sleep(1);
	} 
}

void fun2() { 
	while (true) { 
		std::unique_lock<std::mutex> locker(mu); 
		cond.wait(locker, [](){return !q.empty();}); 
		auto data = q.back(); 
		q.pop_back(); 
		// locker.unlock(); // 没有必要，unique_lock会自动解锁
		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()接口用于唤醒所有等待的线程。

那么为什么必须使用unique_lock呢?
原因: 条件变量在wait时会进行unlock再进入休眠, lock_guard并无该操作接口

• wait: 如果线程被唤醒或者超时那么会先进行lock获取锁, 再判断条件(传入的参数)是否成立, 如果成立则wait函数返回否则释放锁继续休眠
• notify: 进行notify动作并不需要获取锁

总结

• lock_guard
  • std::lock_guard 在构造函数中进行加锁，析构函数中进行解锁。
  • 锁在多线程编程中，使用较多，因此c++11提供了lock_guard模板类；在实际编程中，我们也可以根
    据自己的场景编写resource_guard RAII类，避免忘掉释放资源。
• std::unique_lock
  • unique_lock 是通用互斥包装器，允许延迟锁定、锁定的有时限尝试、递归锁定、所有权转移和与条件变量一同使用。
  • unique_lock比lock_guard使用更加灵活，功能更加强大。
  • 使用unique_lock需要付出更多的时间、性能成本。

需要结合notify+wait的场景使用unique_lock； 如果只是单纯的互斥使用lock_guard