c++多线程thread与线程安全mutex、cond条件变量

windows的线程库与linux的线程库是不一样的，要想在两个平台下跑通，就需要使用条件编译。

但是c++为我们提供了一个thread库，对windows与linux的底层库进行了封装，使其具有了一定跨平台性。

c++的线程库是同享一份地址空间的，与linux的轻量级线程类似。

1介绍几个常用的

从这里就可以看出来c++的线程是不支持拷贝构造的(也没有什么实际的意义)，但是支持无参构造与移动构造/赋值 。

2.代码示例

2.1线程不安全代码： 

int g_x=0;
void addNum(int num) {
	for (int i = 0; i <= num - 1;i++) {
		g_x++;
	}
}

int main() {
	int total=10000;
	thread t1(addNum,total);
	thread t2(addNum,total);
	t1.join();
	t2.join();
	cout << g_x << endl;
	return 0;
}

 2.2注意区分这种局部锁

int g_x=0;
void addNum(int num) {
	mutex mux;
	mux.lock();
	for (int i = 0; i <= num - 1;i++) {
		g_x++;
	}
	mux.unlock();
}

int main() {
	int total=10000;
	thread t1(addNum,total);
	thread t2(addNum,total);
	t1.join();
	t2.join();
	cout << g_x << endl;
	return 0;
}

 所以这里需要一把两个线程共享的锁，而不是一个线程一个锁

int g_x=0;
void addNum(int num,mutex &mux) {
	mux.lock();
	for (int i = 0; i <= num - 1;i++) {
		g_x++;
	}
	mux.unlock();
}

int main() {
	int total=10000;
	mutex mux;
	thread t1(addNum, total, ref(mux));
	thread t2(addNum,total, ref(mux));
	t1.join();
	t2.join();
	cout << g_x << endl;
	return 0;
}

2.3在创建线程要传递引用对象时，需要使用ref 

注意这里传递参数时，由于mutex不支持拷贝，即便我们的addNum使用引用接收也是会报错，此时需要使用关键字ref来传递这个引用，在需要引用传递时。不用关注是怎么实现的，这里仅仅知道需要这么做就行。

2.4锁的粒度

来对比如下两个代码：

int g_x=0;
void addNum1(int num,mutex &mux) {
	mux.lock();
	for (int i = 0; i <= num - 1;i++) {
		g_x++;
	}
	mux.unlock();
}

void addNum2(int num, mutex& mux) {
	for (int i = 0; i <= num - 1; i++) {
		mux.lock();
		g_x++;
		mux.unlock();
	}
}

哪种锁的方式运行效率高？

答案：第一种，即addNum1的运行方式高，因为线程获取到锁后，可以在for里面跑很久。而第二种for循环一次，就要申请锁与释放锁。在次过程中，当前线程被系统切走的概率提升，被切走也就意味着cpu内的寄存器数据要进行一次换入与换出。时间消耗很大。

虽然说锁的粒度越小越好，但是我们锁内的for循环消耗时间更少，所以这里锁加在for循环外面比较好。

即虽然我们要求锁的粒度越小越好，但是也要分场景(加锁解锁时间比锁保护代码运行时间还长)，如果锁之间的操作很简单，则需要改变我们的策略  ，因为加锁解锁会导致进程的上下文频繁切换 。

当我们锁内有较为耗时的动作时，我们在考虑把其放到锁的外面，比如IO操作

2.5递归锁

recursive_mutex

recursive_mutex _mux;
int x = 0;
void func(int i) {
	if (i == 0) {
		return;
	}
	_mux.lock();
	x++;
	func(i - 1);
	_mux.unlock();
}

int main() {
	thread t1(func,1000);
	thread t2(func,2000);
	t1.join();
	t2.join();
	return 0;
}

如果用普通的锁，我们lock后，进入func(i-1)，再去获取lock时，就获取不到了，这是就需要使用递归锁，原理是判断遇到的锁是不是同一个锁，如果是的话就往下走。

2.6RAII风格的锁: lock_guard

mutex g_mux;
int g_val= 0;
void func(int n) {
	lock_guard<mutex> lock(ref(g_mux));
	
	for(int i = 0; i < n;i++) {
		g_val++;
	}
}
int main() {
	thread t1(func,10000);
	thread t2(func, 20000);
	t1.join();
	t2.join();
	cout << g_val << endl;
	return 0;
}

   2.7 unique_lock

     unique_lock 是一个类 模板， 的功能 lock_guard 类似，但是比lock_guard  更加灵活 ，在日常的开发工作中 般情况下 。Iock_guard 就够用了。具体使用文章可看下面的

多线程05：unique_lock详解 - D-booker - 博客园 (cnblogs.com)

 3.原子操作atomic

原子操作在多线程下是线程安全的，因为原子只有两个太，做了、或者没做

原子底层的技术为CAS，具体的可以百度so

示例代码 

mutex g_mux;
atomic<int> x = 0;//原子的，线程安全
void func(int n) {
	for(int i = 0; i < n;i++) {
		x++;
	}
}
int main() {
	thread t1(func,10000);
	thread t2(func, 20000);
	t1.join();
	t2.join();
	cout << x << endl;
	return 0;
}

原子操作只能支持一下类型：

内置类型--->

 4.条件变量condition_variable

与linux的cond功能一样

4.1wait

等待条件就绪

wait的前提是需要先获取锁

所以调用wait前，应该先使用lock加上锁

进入wait后，会释放锁，变成等待条件就绪，

如果条件就绪后，需要先获取锁，再往下运行。

4.2notify 唤醒

唤醒等待这个条件的一个线程，如果没有等待，就什么都不做

如果有多个线程都在等条件，就随即唤醒一个。

5.一个小题

现有两个线程A与B ，让线程A打印奇数，线程B打印偶数，从0-100。

依次打印出来。该怎么做？

1.线程A与B访问同一个资源，要保证资源安全，可以使用mutex

2.线程A与B要交替运行，依次打印奇数与偶数,可以使用cond条件变量

int main() {
	int value = 0;
	mutex mux;
	condition_variable cond;
	thread t1([&]() {//打印奇数
		//unique_lock<mutex> lock(mux); 能把锁加在这里吗？
		while (1) {
			unique_lock<mutex> lock(mux);
			if (value>99) {
				break;
			}
			if (value%2==0) {//偶数
				cond.wait(ref(lock));
			}
			cout << this_thread::get_id() << "->" << value << endl;
			value++;
			cond.notify_one();
		}
		});
	thread t2([&]() {//打印偶数
		while (1) {
			unique_lock<mutex> lock(mux);
			if (value>=101) {
				break;
			}
			if (value % 2 != 0) {//偶数
				cond.wait(ref(lock));
			}
			cout << this_thread::get_id() << "->" << value << endl;
			value++;
			cond.notify_one();
		}
		});
	t1.join();
	t2.join();

	return 0;
}