C++11thread_c++11 thread

C++11线程库

1thread类的简单介绍

在C++11之前,涉及到多线程问题,都是与平台相关的,比如Windows和linux下都有各自的接口,这使得代码的可移植性比较差,C++11中最重要的特性就是对线程进行支持了,使得C++在并行编程时不需要依赖第三方库,而且在原子操作中还引入了原子类的概念.要使用标准库中的线程,必须包含<thread>头文件.

 注意:

1. 线程是操作系统中的一个概念,线程对象可以关联一个线程,用来控制线程以及获取线程的状态
2. 当创建一个线程对象后,没有提供线程函数,该对象实际没有对应任何线程
3. 当创建一个线程对象后,并且给线程关联线程函数,该线程就被启动,与主线程一起运行.线程函数一般情况下可按照以下三种方式提供:
   1. 函数指针
   2. lambda表达式
   3. 函数对象
4. thread类是防拷贝的,不允许拷贝构造以及赋值,但是可以移动构造和移动赋值,即将一个线程对象关联线程的状态转移给其它线程对象,转移期间不意向线程的执行
5. 可以通过joinable()函数判断线程是否有效,如果是以下任意情况,则线程无效
   1. 采用无参构造函数构造的线程对象
   2. 线程对象的状态已经转移给其它线程对象
   3. 线程已经调用join或者detach结束

拓展:并发与并行的区别:

并发是指一个处理器同时处理多个任务。
并行是指多个处理器或者是多核的处理器同时处理多个不同的任务。
并发是逻辑上的同时发生，而并行是物理上的同时发生。
来个比喻：并发是一个人同时吃三个馒头，而并行是三个人同时吃三个馒头。

2.线程函数参数

线程函数的参数是以值拷贝的方式拷贝到线程栈中的,因此:即使线程参数为引用类型,在线程中修改后也不能修改外部实参,因为其实际引用的是线程栈中的拷贝,而不是外部实参.

#include <iostream>
#include <thread>
using namespace std;
 
void func(int& a) {
	a += 20;
}
int main() {
	int a = 10;
	thread t1(func, a);
	t1.join();
	cout << a << endl; //10  在线程函数中对a进行修改,不会影响外部实参,因为:线程函数虽然是引用方式,但其实际引用的是线程栈中的拷贝
 
	thread t2(func, ref(a));
	t2.join();
	cout << a << endl;  //30  如果想要通过形参改变外部实参时,必须借助std::ref()函数
	return 0;
}

注意:如果类成员函数作为线程参数时,必须将this作为线程函数参数.

3.join和detach

启动一个线程后,当这个线程结束的时候,如何去回收线程所使用的资源呢?thread库给我们两种选择:

3.1 join()方式

join():主线程被阻塞,当新线程终止时,join()会清理相关的线程资源,然后返回,主线程再继续向下执行,然后销毁线程对象.由于join()清理了线程的相关资源,thread对象与已销毁的线程就没有关系了,因此一个线程对象只能使用一次join(),否则程序会崩溃.

join()的误用:

1. join()调用之前,主线程return
2. join()调用之前,主线程抛异常

导致新线程的资源没有被回收.

因此:采用join()方式结束线程时,join()的调用位置非常关键.为了避免g该问题,可以采用RAII的方式对线程对象进行封装.

#include <iostream>
#include <thread>
using namespace std;
 
class Thread {
public:
	explicit Thread(thread& t1) //不能隐式构造
		:_t(t1)
	{}
	~Thread() {
		if (_t.joinable()) {
			_t.join();
		}
	}
	//不允许拷贝和赋值
	Thread(const Thread&) = delete;
	Thread& operator=(const Thread&) = delete;
private:
	thread& _t;
};
void f() {
	cout << "f()" << endl;
}
 
bool DoSomething() { 
	return false;
}
 
int main() {
	thread t(f);
	Thread q(t);
	if (!DoSomething())
		return -1;
	return 0;
}

3.2 detach()方式

detach():该函数被调用后,新线程与线程对象分离,不再被线程对象所表达,就不能通过线程对象控制线程了,新线程会在后台运行,其所有权和控制权将会交给C++运行库.同时,C++运行库保证,当线程退出时,其相关资源能够正确的回收.

detach()函数一般在线程对象创建好之后就调用,因为如果不是join()等待方式结束,那么线程对象可能会在新线程结束之前被销毁而导致程序崩溃.因为std::thread的析构函数中,如果线程的状态是joinable,std::terminate将会被调用,而terminate()函数直接回终止程序.

因此:线程对象销毁前,要么以join()的方式等待线程结束,要么以detach()的方式将线程与线程对象分离.

4.原子性操作库

多线程最主要的问题是共享数据带来的问题(即线程安全).如果共享数据都只是可读的,那么没问题,因为只读操作不会影响到数据,更不会设计对数据的修改,所以所有线程都会获取同样的数据.但是当一个或多个线程要修改共享数据时,就会产生很多潜在的麻烦.

#include <iostream>
#include <thread>
using namespace std;
 
unsigned long sum = 0L;
void fun(size_t num) {
	for (size_t i = 0; i < num; ++i) {
		sum++;
	}
}
 
int main() {
	cout << "Brfore joining,sum= " << sum << endl;
 
	thread t1(fun, 10000000);
	thread t2(fun, 10000000);
	t1.join();
	t2.join();
	cout << "After joining,sum= " << sum << endl;
	return 0;
}

C++98中传统的解决方式:可以对共享修改的数据可以加锁保护.

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;
 
mutex m;
unsigned long sum = 0L;
void fun(size_t num) {
	for (size_t i = 0; i < num; ++i) {
		m.lock();
		sum++;
		m.unlock();
	}
}
 
int main() {
	cout << "Brfore joining,sum= " << sum << endl;
 
	thread t1(fun, 10000000);
	thread t2(fun, 10000000);
	t1.join();
	t2.join();
	cout << "After joining,sum= " << sum << endl;
	return 0;
}

虽然加锁可以解决,但是加锁有一个缺陷就是:只要一个线程在对sum++时,其它线程就会被阻塞,会影响程序运行的效率,而且锁如果控制不好,还容易造成死锁.

因此C++11中引入了原子操作.所谓原子操作:即不可被中断的一个或一系列操作,C++11引入的原子操作类型,使得线程间数据的同步变得非常高效. 

#include <iostream>
#include <thread>
#include <atomic>
using namespace std;
atomic_ulong sum{ 0 };
 
void fun(size_t num) {
	for (size_t i = 0; i < num; ++i) {
		sum++;
	}
}
 
int main() {
	cout << "Brfore joining,sum= " << sum << endl;
 
	thread t1(fun, 10000000);
	thread t2(fun, 10000000);
	t1.join();
	t2.join();
	cout << "After joining,sum= " << sum << endl;
	return 0;
}

 在C++11中,程序员不需要对原子类型变量进行加锁解锁操作,线程能够对原子类型变量互斥的访问.

更为普遍的,可以使用atomic类模板,定义出需要的任意原子类型.

注意:原子类型通常属于"资源型"数据,多个线程只能访问单个原子类型的拷贝,因此在C++11中,原子类型只能从其模板参数中进行构造,不允许原子类型进行拷贝构造,移动构造以及operator=等,为了防止意外,标准库已经将atomic模板类中的拷贝构造,移动构造,赋值运算符重载默认删除掉了.

5.mutex的种类

在C++11中,mutex总共包含四个互斥量的种类:

1.mutex

C++11提供的最基本的互斥量,该类的对象之间不能拷贝,也不能移动.mutex最常用的三个函数:

注意:线程函数调用lock()时,可能会出现以下三种情况:

1. 如果该互斥量当前没有被锁住,则调用线程将该互斥量锁住,直到调用unlock之前,该线程一直拥有该锁
2. 如果当前互斥量被其它线程锁住,则当前的调用线程被阻塞住
3. 如果当前互斥量被当前调用线程锁住,则会产生死锁

线程函数调用try_lock()时,可能会出现以下三种情况:

1. 如果当前互斥量没有被其它线程占有,则该线程锁住互斥量,直到该线程调用unlock()释放互斥量
2. 如果当前互斥被其它线程锁住,则当前调用线程返回false,而并不会阻塞掉
3. 如果当前互斥量被当前调用线程锁住,则会产生死锁

2.recursive_mutex

允许同一个线程对互斥量多次上锁(即递归上锁),来获得对互斥量对象的多层所有权,释放互斥量时需要调用与该锁层次深度相同次数的unlock(),除此之外,recursive_mutex和mutex的特性大致相同.

3.timed_mutex

比mutex多两个成员函数:

• try_lock_for

接受一个时间范围,表示在这一段时间范围之内线程如果没有获得锁则被阻塞住(与mutex的try_lock()不同,try_lock如果被调用时没有获得锁则直接返回false),如果在此期间其它线程释放了锁,则该线程可以获得对互斥量的锁,如果超时(即在指定时间内没有获得锁),则返回false.

• try_lock_until()

接受一个时间点作为参数,在指定时间点未到来之前线程如果没有获得锁则被阻塞住,如果在此期间其它线程释放了锁,则g该线程可以获得对互斥量的锁,如果超时(即在指定时间内还是没有获得锁),则返回false.

4.recursive_timed_mutex

6.lock_guard与unique_lock

lock_guard

在多线程环境下,如果想要保证某个变量的安全性,只要将其设置成对应的原子类型即可,既高效又不容易出现死锁问题.

锁控制不好时,可能会造成死锁,最常见的比如是在锁中间代码返回,或者在锁的范围内抛异常.因此:C++11采用RAII的方式对锁进行了封装,即lock_guard和unique_lock.

#include <iostream>
#include <memory>
#include <mutex>
using namespace std;
 
template<class _Mutex>
class lock_guard {
public:
	explicit lock_guard(_Mutex& mtx)
		:_mtx(mtx)
	{
		_mtx.lock();
	}
 
	lock_guard(_Mutex& mtx,adopt_lock_t)
		:_mtx(mtx)
	{}
	~lock_guard() _NOEXCEPT{
		_mtx.unlock();
	}
	lock_guard(const lock_guard&) = delete;
	lock_guard& operator=(const lock_guard&) = delete;
private:
	_Mutex& _mtx;
};

lock_guard类模板主要是通过RAII的方式,对其管理的互斥量进行了封装,在需要加锁的地方,只需要用上述介绍的任意互斥体实例化一个lock_guard,调用构造函数成功上锁,出作用域前,lock_guard对象就要被销毁,调用析构函数自动解锁,可以有效避免死锁问题.

lock_guard的缺陷:太单一,用户没有办法对该锁进行控制,因此C++11又提供了unique_lock.

unique_lock:

与lock_gard类似，unique_lock类模板也是采用RAII的方式对锁进行了封装，并且也是以独占所有权的方式 管理mutex对象的上锁和解锁操作，即其对象之间不能发生拷贝。在构造(或移动(move)赋值)时， unique_lock 对象需要传递一个 Mutex 对象作为它的参数，新创建的 unique_lock 对象负责传入的 Mutex 对象的上锁和解锁操作。使用以上类型互斥量实例化unique_lock的对象时，自动调用构造函数上锁， unique_lock对象销毁时自动调用析构函数解锁，可以很方便的防止死锁问题。

与lock_guard不同的是，unique_lock更加的灵活，提供了更多的成员函数：

• 上锁/解锁操作：lock、try_lock、try_lock_for、try_lock_until和unlock
• 修改操作：移动赋值、交换(swap：与另一个unique_lock对象互换所管理的互斥量所有权)、释放 (release：返回它所管理的互斥量对象的指针，并释放所有权)
• 获取属性：owns_lock(返回当前对象是否上了锁)、operator bool()(与owns_lock()的功能相同)、mutex(返回当前unique_lock所管理的互斥量的指针)。