发布时间:2023-04-21 18:30
在C++11之前,涉及到多线程问题,都是和平台相关的,比如windows和linux下各有自己的接口,这使得代码的可移植性比较差。C++11中最重要的特性就是对线程进行支持了,使得C++在并行编程时不需要依赖第三方库,而且在原子操作中还引入了原子类的概念。要使用标准库中的线程,必须包含< thread >头文件。C++11中线程类
构造一个线程对象,没有关联任何线程函数,即没有启动任何线程
构造一个线程对象,并关联线程函数 Fn,args1,args2,…为线程函数的参数
获取线程id
线程是否还在执行,joinable代表的是一个正在执行中的线程
该函数调用后会阻塞住线程,当该线程结束后,主线程继续执行
在创建线程对象后马上调用,用于把被创建线程与线程对象分离开,分离的线程变为后台线程,创建的线程的\"死活\"就与主线程无关
注意:
#include
int main()
{
std::thread t1;
cout << t1.get_id() << endl;
return 0;
}
get_id()的返回值类型为id类型,id类型实际为std::thread命名空间下封装的一个类,该类中包含了一个结构体:
//vs下查看
typedef struct
{ //thread identifier for Win32
void* _Hnd; //Win32 HANDLE
unsigned int _Id;
} _Thrd_imp_t;
#include
using namespace std;
#include
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;
}
小问题:并发与并行的区别?
【Concurrency】并发
并发的反义词是顺序,concurrency vs sequential,例如:
顺序处理:你陪女朋友先看电影(Task1),看完后陪女朋友到花店买了一束花(Task2),然后陪女朋友去西餐厅吃烛光晚餐(Task3),这就是“顺序处理”,因为整个过程中只有你这一个处理器,事情只能一件一件的做(要么是你亲自做,要么你要等别人做)。Task1你要花2小时,Task2等花做好你要花30分钟,Task3等菜做好要30分钟,从你开始看电影到开始吃饭,全程需要3小时(假设走路不算时间)。
并发处理:你陪女朋友先看电影(Task1),同时打电话给花店预定一束花,花店安排人员在20:00送到西餐厅(Task2);同时你打电话给西餐定预定20:00的浪漫烛光晚餐,西餐厅开始给你准备晚餐(Task3);等到你电影看完跑到西餐厅,花也送到了,晚餐也准备好了,你跑过去直接献花吃饭然后开房即可,这就是并发处理。Task1还是2小时,但Task2和Task3也在这2小时完成了,从你开始看电影到开始吃饭,全程只需要2小时,3个任务是并发完成的。秘诀就是有3个处理器了:你、花店、餐厅在同一个时间段内都在做各自的任务。
【Parallelism】并行
并行的反义词是串行,Parallelism vs Serial,比如说给你一个100万的整形数组,挑出其中最小的值。
串行处理
从数组的第一个开始扫描到最后一个,类似冒泡排序一样
并行处理
将数组分为10组,每组10万个整形,同时扫描10组得到10个数值,然后再将这10个数值排列一下。
上面这个简单的例子也可以看出,串行改为并行其实并不那么简单,涉及到任务分解(有先后依赖的任务就不能做到并行)、任务运行(可能要考虑互斥、锁、共享等)、结果合并。
线程函数的参数是以值拷贝的方式拷贝到线程栈空间中的,因此:即使线程参数为引用类型,在线程中修改后也不能修改外部实参,因为其实际引用的是线程栈中的拷贝,而不是外部实参。
#include
using namespace std;
#include
void ThreadFunc1(int& x)
{
x += 10;
}
void ThreadFunc2(int* x)
{
*x += 10;
}
int main()
{
int a = 10;
// 在线程函数中对a修改,不会影响外部实参,因为:线程函数参数虽然是引用方式,但其实际引用的是线程栈中的拷贝
thread t1(ThreadFunc1, a);
t1.join();
cout << a << endl;
// 如果想要通过形参改变外部实参时,必须借助std::ref()函数
thread t2(ThreadFunc1, std::ref(a));
t2.join();
cout << a << endl;
// 地址的拷贝
thread t3(ThreadFunc2, &a);
t3.join();
cout << a << endl;
return 0;
}
注意:如果是类成员函数作为线程参数时,必须将this作为线程函数参数。
启动了一个线程后,当这个线程结束的时候,如何去回收线程所使用的资源呢?thread库给我们两种选择:
join()的误用一
如果DoSomething()函数返回false,主线程将会结束,join()没有调用,线程资源没有回收,造成资源泄漏。
void ThreadFunc()
{
cout << \"ThreadFunc()\" << endl;
}
bool DoSomething()
{
return false;
}
int main()
{
std::thread t(ThreadFunc);
if (!DoSomething())
return -1;
t.join();
return 0;
}
join()的误用二
void ThreadFunc()
{
cout << \"ThreadFunc()\" << endl;
}
void Test1()
{
throw 1;
}
void Test2()
{
int* p = new int[10];
std::thread t(ThreadFunc);
try
{
Test1();
}
catch (...)
{
delete[] p;
throw;
}
t.join();
}
因此:采用join()方式结束线程时,join()的调用位置非常关键。为了避免该问题,可以采用RAII的方式对线程对象进行封装,比如:
#include
class mythread
{
public:
explicit mythread(std::thread& t)
: m_t(t)
{}
~mythread()
{
if (m_t.joinable())
{
m_t.join();
}
}
mythread(const mythread&) = delete;
mythread& operator=(const mythread&) = delete;
private:
std::thread& m_t;
};
void ThreadFunc()
{
cout << \"ThreadFunc()\" << endl;
}
bool DoSomething()
{
return false;
}
int main()
{
thread t(ThreadFunc);
mythread q(t);
if (DoSomething())
{
return -1;
}
return 0;
}
就像是你和你女朋友分手,那之后你们就不会再有联系(交互)了,而她的之后消费的各种资源也就不需要你去买单了(清理资源)。
detach()函数一般在线程对象创建好之后就调用,因为如果不是join()等待方式结束,那么线程对象可能会在新线程结束之前被销毁掉而导致程序崩溃。因为std::thread的析构函数中,如果线程的状态是joinable,std::terminate将会被调用,terminate()函数直接会终止程序。
因此:线程对象销毁前,要么以join()的方式等待线程结束,要么以detach()的方式将线程与线程对象分离。
多线程最主要的问题是共享数据带来的问题(即线程安全)。如果共享数据都是只读的,那么没问题,因为只读操作不会影响到数据,更不会涉及对数据的修改,所以所有线程都会获得同样的数据。但是,当一个或多个线程要修改共享数据时,就会产生很多潜在的麻烦。比如:
#include
using namespace std;
#include
unsigned long sum = 0L;
void fun(size_t num)
{
for (size_t i = 0; i < num; ++i)
{
sum++;
}
}
int main()
{
cout << \"Before joining,sum = \" << sum << std::endl;
thread t1(fun, 10000000);
thread t2(fun, 10000000);
t1.join();
t2.join();
cout << \"After joining,sum = \" << sum << std::endl;
return 0;
}
C++98中传统的解决方式:可以对共享修改的数据可以加锁保护。
#include
using namespace std;
#include
#include
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 << \"Before joining,sum = \" << sum << std::endl;
thread t1(fun, 10000000);
thread t2(fun, 10000000);
t1.join();
t2.join();
cout << \"After joining,sum = \" << sum << std::endl;
return 0;
}
虽然加锁可以解决,但是加锁有一个缺陷就是:只要一个线程在对sum++时,其他线程就会被阻塞,会影响程序运行的效率,而且锁如果控制不好,还容易造成死锁。
因此C++11中引入了原子操作。所谓原子操作:即不可被中断的一个或一系列操作,C++11引入的原子操作类型,使得线程间数据的同步变得非常高效。
注意:需要使用以上原子操作变量时,必须添加头文件#include
#include
using namespace std;
#include
#include
atomic_long sum{ 0 };
void fun(size_t num)
{
for (size_t i = 0; i < num; ++i)
{
sum++; //原子操作
}
}
int main()
{
cout << \"Before joining, sum = \" << sum << std::endl;
thread t1(fun, 1000000);
thread t2(fun, 1000000);
t1.join();
t2.join();
cout << \"After joining, sum = \" << sum << std::endl;
return 0;
}
在C++11中,我们不需要对原子类型变量进行加锁解锁操作,线程能够对原子类型变量互斥的访问。
更为普遍的,我们可以使用atomic类模板,定义出需要的任意原子类型。
atmoic<T> t; // 声明一个类型为T的原子类型变量t
注意:原子类型通常属于\"资源型\"数据,多个线程只能访问单个原子类型的拷贝,因此在C++11中,原子类型只能从其模板参数中进行构造,不允许原子类型进行拷贝构造、移动构造以及operator=等,为了防止意外,标准库已经将atmoic模板类中的拷贝构造、移动构造、赋值运算符重载默认删除掉了。
#include
int main()
{
atomic<int> a1(0);
//atomic a2(a1); // 编译失败
atomic<int> a2(0);
//a2 = a1; // 编译失败
return 0;
}
原子操作
在多线程环境下,如果想要保证某个变量的安全性,只要将其设置成对应的原子类型即可,即高效又不容易出现死锁问题。但是有些情况下,我们可能需要保证一段代码的安全性,那么就只能通过锁的方式来进行控制。
比如:一个线程对变量number进行加一100次,另外一个减一100次,每次操作加一或者减一之后,输出number的结果。
#include
using namespace std;
#include
#include
int number = 0;
mutex g_lock;
int ThreadProc1()
{
for (int i = 0; i < 100; i++)
{
g_lock.lock();
++number;
cout << \"thread 1 :\" << number << endl;
g_lock.unlock();
}
return 0;
}
int ThreadProc2()
{
for (int i = 0; i < 100; i++)
{
g_lock.lock();
--number;
cout << \"thread 2 :\" << number << endl;
g_lock.unlock();
}
return 0;
}
int main()
{
thread t1(ThreadProc1);
thread t2(ThreadProc2);
t1.join();
t2.join();
cout << \"number:\" << number << endl;
return 0;
}
上述代码的缺陷:锁控制不好时,可能会造成死锁,最常见的比如在锁中间代码返回,或者在锁的范围内抛异常。因此:C++11采用RAII的方式对锁进行了封装,即lock_guard和unique_lock。
lock_guard
std::lock_gurad 是 C++11 中定义的模板类。定义如下:
template<class _Mutex>
class lock_guard
{
public:
// 在构造lock_gard时,_Mtx还没有被上锁
explicit lock_guard(_Mutex& _Mtx)
: _MyMutex(_Mtx)
{
_MyMutex.lock();
}
// 在构造lock_gard时,_Mtx已经被上锁,此处不需要再上锁
lock_guard(_Mutex& _Mtx, adopt_lock_t)
: _MyMutex(_Mtx)
{}
~lock_guard() _NOEXCEPT
{
_MyMutex.unlock();
}
lock_guard(const lock_guard&) = delete;
lock_guard& operator=(const lock_guard&) = delete;
private:
_Mutex& _MyMutex;
};
通过上述代码可以看到,lock_guard类模板主要是通过RAII的方式,对其管理的互斥量进行了封装,在需要加锁的地方,只需要用上述介绍的任意互斥体实例化一个lock_guard,调用构造函数成功上锁,出作用域前,lock_guard对象要被销毁,调用析构函数自动解锁,可以有效避免死锁问题。
lock_guard的缺陷:太单一,用户没有办法对该锁进行控制,因此C++11又提供了unique_lock。
与lock_gard类似,unique_lock类模板也是采用RAII的方式对锁进行了封装,并且也是以独占所有权的方式管理mutex对象的上锁和解锁操作,即其对象之间不能发生拷贝。在构造(或移动(move)赋值)时,unique_lock 对象需要传递一个 Mutex 对象作为它的参数,新创建的 unique_lock 对象负责传入的 Mutex对象的上锁和解锁操作。使用以上类型互斥量实例化unique_lock的对象时,自动调用构造函数上锁,unique_lock对象销毁时自动调用析构函数解锁,可以很方便的防止死锁问题。
与lock_guard不同的是,unique_lock更加的灵活,提供了更多的成员函数:
lock_guard/unique_lock详解
IntelliJ IDEA中如何优雅的调试Java Stream操作
springboot+vue项目使用jwt token验证登录,token验证失败
【k8s部署 】k8s构建Flannel网络插件失败The connection to the server raw.githubusercontent.com was refused问题解决
斯坦福NLP名课带学详解 | CS224n 第15讲 - NLP文本生成任务(NLP通关指南·完结)
国家加强网络数据安全管控 中信国安鸿联九五助力企业保障数据安全
视觉slam需要会matlab吗,研究SLAM,对编程的要求有多高?