C++11线程库
1thread类的简单介绍
在C++11之前,涉及到多线程问题,都是与平台相关的,比如Windows和linux下都有各自的接口,这使得代码的可移植性比较差,C++11中最重要的特性就是对线程进行支持了,使得C++在并行编程时不需要依赖第三方库,而且在原子操作中还引入了原子类的概念.要使用标准库中的线程,必须包含<thread>头文件.
| 函数名 | 功能 |
| thread() |
构造一个线程对象,没有关联任何线程函数,即没有启动任何线程 |
| thread(fn,args1,args2,...) | 构造一个线程对象,并关联线程函数fn,args1,args2,...为线程函数的参数 |
| get_id() | 获取线程id |
| joinable() | 线程是否还在执行,当该线程结束后,主线程继续执行 |
| join() | 该函数调用后会阻塞住线程,当该线程结束后,主线程继续执行 |
| detach() | 在创建线程对象后马上调用,用于把被创建线程与线程对象分离开,分离的线程变为后台线程,创建的线程的"死活"就与主线程无关 |
注意:
- 线程是操作系统中的一个概念,线程对象可以关联一个线程,用来控制线程以及获取线程的状态
- 当创建一个线程对象后,没有提供线程函数,该对象实际没有对应任何线程
- 当创建一个线程对象后,并且给线程关联线程函数,该线程就被启动,与主线程一起运行.线程函数一般情况下可按照以下三种方式提供:
- 函数指针
- lambda表达式
- 函数对象
- thread类是防拷贝的,不允许拷贝构造以及赋值,但是可以移动构造和移动赋值,即将一个线程对象关联线程的状态转移给其它线程对象,转移期间不意向线程的执行
- 可以通过joinable()函数判断线程是否有效,如果是以下任意情况,则线程无效
- 采用无参构造函数构造的线程对象
- 线程对象的状态已经转移给其它线程对象
- 线程已经调用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()的误用:
- join()调用之前,主线程return
- 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() | 上锁:锁住互斥量 |
| unlock() | 解锁:释放对互斥量的所有权 |
| try_lock() | 尝试锁住互斥量,如果互斥量被其它线程占有,则当前线程不会被阻塞 |
注意:线程函数调用lock()时,可能会出现以下三种情况:
- 如果该互斥量当前没有被锁住,则调用线程将该互斥量锁住,直到调用unlock之前,该线程一直拥有该锁
- 如果当前互斥量被其它线程锁住,则当前的调用线程被阻塞住
- 如果当前互斥量被当前调用线程锁住,则会产生死锁
线程函数调用try_lock()时,可能会出现以下三种情况:
- 如果当前互斥量没有被其它线程占有,则该线程锁住互斥量,直到该线程调用unlock()释放互斥量
- 如果当前互斥被其它线程锁住,则当前调用线程返回false,而并不会阻塞掉
- 如果当前互斥量被当前调用线程锁住,则会产生死锁
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所管理的互斥量的指针)。
扫一扫
1578
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
