引言
在C++11之前,涉及到多线程问题,都是和平台相关的,比如windows和linux下各有自己的接
口,这使得代码的可移植性比较差。C++11中最重要的特性就是对线程进行支持了,使得C++在
并行编程时不需要依赖第三方库。要使用标准库中的线程,必须包含< thread >头文件。
thread类介绍
函数名功能
-
thread() :构造一个线程对象,没有关联任何线程函数,即没有启动任何线程
-
thread(fn,args1, args2,…):构造一个线程对象,并关联线程函数fn,args1,args2,…为线程函数的参数
-
get_id():获取线程id
-
jionable() :判断线程是否还在执行,joinable代表的是一个正在执行中的线程。
-
jion() :该函数调用后会阻塞住线程,当该线程结束后,主线程继续执行
-
detach():在创建线程对象后马上调用,用于把被创建线程与线程对象分离开,分离
的线程变为后台线程,创建的线程的"死活"就与主线程无关
线程是操作系统中的一个概念,线程对象可以关联一个线程,用来控制线程以及获取线程的状态。
当创建一个线程对象后,没有提供线程函数,该对象实际没有对应任何线程。
当创建一个线程对象后,并且给线程关联线程函数,该线程就被启动,与主线程一起运行。
线程函数一般情况下可按照以下三种方式提供:
- 函数指针
- lambda表达式
- 函数对象
以下为创建线程对象并关联线程函数实例:
#include <iostream>
using namespace std;
#include <thread>
void ThreadFunc(int a)
{
cout << "Thread1" << a << endl;
}
class TF
{
public:
void operator()()
{
cout << "Thread3" << endl;
}
};
int main()
{
// 线程函数为函数指针
thread t1(ThreadFunc, 10);
// 线程函数为lambda表达式
thread t2([] {cout << "Thread2" << endl; });
// 线程函数为函数对象
TF tf;
thread t3(tf);
t1.join();
t2.join();
t3.join();
cout << "Main thread!" << endl;
return 0;
}
传入参数需要注意的一些细节:
例如如果传入引用类型的话,需要加上ref进行转化。
class A
{
public:
void fun1(int a, int b)
{
cout << "fun1(int, int)" << a << b << endl;
}
};
void fun(int& a)
{
a *= 2;
}
void fun1(int* ptr)
{
*ptr *= 2;
}
int main()
{
A a;
//成员函数需要显示取地址,隐含的this指针地址也要传入
thread t1(&A::fun1, &a, 10, 20);
t1.join();
int a2 = 1;
thread t2(fun, a2);
t2.join();
cout << a2 << endl;
thread t3(fun1, &a2);
t3.join();
cout << a2 << endl;
//参数如果为引用类型,需要加ref转换
thread t4(fun, ref(a2));
t4.join();
cout << a2 << endl;
return 0;
}
原子性操作库(atomic)
多线程最主要的问题是共享数据带来的问题(即线程安全)。如果共享数据都是只读的,那么没问题,因为只读操作不会影响到数据,更不会涉及对数据的修改,所以所有线程都会获得同样的数据。但是,当一个或多个线程要修改共享数据时,就会产生很多潜在的麻烦。
如下:
int sum = 0;
void fun(int n)
{
for (int i = 0; i < n; ++i)
{
sum++;
}
}
- C++98中传统的解决方式:可以对共享修改的数据可以加锁保护。
#include<mutex>
int sum = 0;
mutex mtx;
void fun(int n)
{
for (int i = 0; i < n; ++i)
{
mtx.lock();
sum++;
mtx.unlock();
}
}
虽然加锁可以解决,但是加锁有一个缺陷就是:只要一个线程在对sum++时,其他线程就会被阻塞,会影响程序运行的效率,而且锁如果控制不好,还容易造成死锁。
- 因此C++11中引入了原子操作。
所谓原子操作:即不可被中断的一个或一系列操作,C++11引入的原子操作类型,使得线程间数据的同步变得非常高效。
#include<atomic>
atomic<int> sum(0);
void fun(int n)
{
for (int i = 0; i < n; ++i)
{
sum++;
}
}
lock_guard与unique_lock
在多线程环境下,如果想要保证某个变量的安全性,只要将其设置成对应的原子类型即可,即高效又不容易出现死锁问题。但是有些情况下,我们可能需要保证一段代码的安全性,那么就只能通过锁的方式来进行控制。
mutex mtx;
void fun1()
{
mtx.lock();
cout << "fun1()" << endl;
int n;
cin >> n;
if (n == 0)
return;
mtx.unlock();
}
上述代码的缺陷:锁控制不好时,可能会造成死锁,最常见的比如在锁中间代码返回,或者在锁的范围内抛异常。
lock_guard
通过RAII的方式,对其管理的互斥量进行了封装,在需要加锁的地方,只需要实例化一个lock_guard,调用构造函数成功上锁,出作用域前,lock_guard对象要被销毁,调用析构函数自动解锁,可以有效避免死锁
问题。
mutex mtx;
template <class Mtx>
class LockGuard
{
public:
LockGuard(Mtx& mtx)
:_mtx(mtx)
{
_mtx.lock();
}
~LockGuard()
{
_mtx.unlock();
}
//防拷贝
LockGuard(const LockGuard<Mtx>& lg) = delete;
LockGuard& operator=(const LockGuard<Mtx>& lg) = delete;
private:
Mtx& _mtx;
};
void fun1()
{
LockGuard<mutex> lg(mtx);
//mtx.lock();
cout << "fun1()" << endl;
int n;
cin >> n;
if (n == 0)
return;
//mtx.unlock();
}
lock_guard的缺陷:太单一,用户没有办法对该锁进行控制
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所管理的互斥量的指针)。