有锁编程

  一个线程对临界区加锁后，在它解锁前，其它线程不能对该临界区加锁，也不能访问该临界区。

  互斥锁：加锁失败的线程被阻塞。锁被释放时线程被唤醒。
  自旋锁：加锁失败不会放弃CPU，直到获得锁。
  读写锁：写锁被获得时，所有申请读锁的线程都被阻塞。写锁没有被获得时，多个线程可以同时获得读锁。

1. 互斥锁

---

  互斥锁 mutex 可以实现互斥。互斥锁包装类 lock_guard 是对 mutex 的封装，类似裸指针与智能指针。互斥锁包装类 unique_lock 是 lock_guard 的升级，具有更多功能。

1.1 mutex

---

  锁 mutex 需要手动解锁，访问资源出现异常会跳过解锁从而引起死锁。
  两个线程申请一个锁，一个线程得到锁，另一个线程被阻塞。同一个线程两次申请一个锁，会引起程序崩溃。对一个锁多次 unlock 不会有什么问题。

mutex mx;
mx.lock();
// todo;
mx.unlock();

1.2 lock_guard

---

  互斥量包装类 lock_guard 在代码块结束时通过析构函数实现自动解锁。它的功能比较简单，只有构造函数和析构函数，只能在代码块结束时解锁，中途不能解锁，而且不能复制。

{
	mutex mx;
	lock_guard<mutex> lg(mx);
	// todo;
}

1.3 unique_lock

---

  互斥锁包装类 unique_lock 有更多的成员函数，包含更多功能。允许延迟锁定、限时深度锁定、递归锁定、锁定所有权转让、与条件变量一起使用等功能。

mutex mx;
unique_lock<mutex> ul(mx, adopt_lock);

  构造函数的第2个参数：

1. adopt_lock：mx已通过mutex::lock()获得锁，通知unique_lock的构造函数不要再上锁。
2. try_to_lock：试图上锁。无论上锁失败与否，都会继续执行而不阻塞。
3. defer_lock：不上锁。

  成员函数：

1. unlock()：显式解锁。
2. try_lock()：同try_to_lock参数。
3. owns_lock()：是否拥有锁。
4. release()：返回所管理的mutex对象指针，并释放所有权。
5. 转让所有权：通过移动构造函数。

2. 条件变量

---

  有互斥锁，为什么还使用条件变量：一个进程第一次申请锁没有释放，第二次再申请那个锁就会引起程序崩溃。使用条件变量可以在申请锁前等待条件，避免直接申请引起崩溃。如果条件满足，wait 函数会原子地 unlock 锁然后再 lock 锁。

3. 自旋锁

---

  C++ 没有自旋锁，自旋锁基于原子操作实现，实现和使用如下。

class SpinLock {
public:
	SpinLock(bool x = false) :flag(x) {}
	void lock() {
		bool expect = false;
		while (!flag.compare_exchange_weak(expect, true))
			expect = false; // 因为flag!=expect时expect会被赋值flag，所以这里要确保expect为false。
	}
	void unlock() {
		flag.store(false);
	}
private:
	atomic<bool> flag;
};

void fun(int* sum, SpinLock& spinLock) {
	for (int i = 0; i < 10000; i++) {
		spinLock.lock();
		(*sum)++;
		spinLock.unlock();
	}
}

int main() {
	int sum = 0;
	SpinLock spinLock;
	thread th1 = thread(fun, &sum, ref(spinLock));
	thread th2 = thread(fun, &sum, ref(spinLock));
	th1.join();
	th2.join();
	cout << sum << endl;
}

4. 参考

---

1.如何避免死锁，博客园，2023。