原文链接:https://mp.weixin.qq.com/s/15Qk6oiUmnS0jMJ41841Cg
近期看到有读者在公众号留言问有没有C++多线程的学习方法,我这里特意总结了下,希望能对大家有所帮助。
什么是多线程?
不介绍,基础知识,直接看维基百科:https://zh.wikipedia.org/wiki/%E5%A4%9A%E7%BA%BF%E7%A8%8B
为什么要用多线程?
不介绍,基础知识,和上面在一个链接。
C++多线程知识点
如何创建线程?
多线程有多种创建方式:pthread、std::thread、std::jthread。
这里我推荐学习C++11引入的std::thread,它较pthread更方便,且在C++中更加常用。
至于std::jthread,不用管,学完std::thread后自然就能学会std::jthread。
关于C++11的多线程具体介绍可以看c++11新特性之线程相关所有知识点
使用std::thread创建线程很简单,直接利用它的构造函数即可:
void func() {
xxxx;
}
int main() {
std::thread t(func);
if (t.joinable()) {
t.join();
}
return 0;
}
注意上面代码,我使用了一个joinable()和join(),为什么要这么做?
因为如果不这么调用,在thread生命周期结束时,程序会crash。原因直接看thread的析构函数:
~thread()
{
if (joinable())
std::terminate();
}
join()和detach()?
上面介绍了不调用join,程序会crash,其实也可以调用detach来避免程序crash,那它俩有什么区别?
join()表示阻塞等待子线程执行结束,子线程结束后才会继续往下执行。
detach()表示与当前对象分离,子线程无论做啥,无论是否执行结束都与我无关,爱咋咋地,最终靠操作系统回收相关资源。
joinable()是什么?
上面代码中出现了joinable(),可以简单理解为如果没有调用join()或者detach(),joinable()就返回true。如果调用了其中一个,joinable()就返回false。它主要就是为了搭配join()和detach()使用。
参数传递问题
多线程其实就是开启一个线程,运行某一个函数,上面的示例是运行的无参函数,那如何运行有参函数?怎么将参数传递进去?其实有好几种方法传递参数,我更倾向于使用的是lambda表达式,将有参函数+参数封装成无参函数,然后多线程调用。
示例代码:
void func(int a, int b) { std::cout << "a + b = " << a + b << std::endl; }
int main() {
auto lambda = []() { func(1, 2); };
std::thread t(lambda);
if (t.joinable()) {
t.join();
}
return 0;
}
关于lambda表达式我之前写过文章介绍,可以看这里:
搞定c++11新特性std::function和lambda表达式
成员函数问题
很多人可能还有疑问,如果多线程运行类对象的成员函数,这里可以使用和上面相同的方法,lambda表达式:
struct A {
void Print() { std::cout << "A\n"; }
};
int main() {
std::shared_ptr<A> a = std::make_shared<A>();
auto func = [a]() { a->Print(); };
std::thread t(func);
if (t.joinable()) {
t.join();
}
return 0;
}
小知识点
创建thread对象的常见方法有下面这两种:
std::thread a(func);
std::thread *a = new thread(func);
delete a;
有人在技术交流群里问过这两种方式的区别,相信仔细阅读过上面内容的你应该知道答案!
给个小提示:两者对象一个在堆上,一个在栈上,生命周期不同,即thread的析构函数调用时机不同,然后可以再结合上面介绍的~thread()的实现,思考一下。
为什么需要锁?
因为多线程读写数据可能存在线程安全问题,为了保证线程安全,其中一种方式就是使用锁。
关于线程安全问题,随便去个网站,比如维基百科、百度百科等,都能找到。 https://zh.wikipedia.org/wiki/%E7%BA%BF%E7%A8%8B%E5%AE%89%E5%85%A8
mutex有四种:
- std::mutex:独占的互斥量,不能递归使用,不带超时功能
- std::recursive_mutex:递归互斥量,可重入,不带超时功能
- std::timed_mutex:带超时的互斥量,不能递归
- std::recursive_timed_mutex:带超时的互斥量,可以递归使用
加解锁方式有三种:
- std::lock_guard:可以RAII方式加锁
- std::unique_lock:比lock_guard多了个手动加解锁的功能
- std::scoped_lock:防止多个锁顺序问题导致的死锁问题而出世的一把锁
示例代码:
std::mutex mutex;
void func() {
std::lock_guard<std::mutex> lock(mutex);
xxxxxxx
}
原子操作
上面介绍过使用锁可以解决线程安全问题,其实简单的变量,比如整型变量等,可以使用原子操作,C++11的原子操作都在<atomic>中。
示例代码:
std::atomic<int> count;
int get() {
count.load();
}
void set(int c) {
count.store(c);
}
上面这两个函数可以在多线程中任意调用,不会出现线程安全问题。
条件变量
条件变量是一种同步机制,可以阻塞一个线程或多个线程,直到其他线程对这些线程通知才会解除阻塞。这种通知和阻塞就需要用到条件变量。
示例代码:
class CountDownLatch {
public:
explicit CountDownLatch(uint32_t count) : count_(count);
void CountDown() {
std::unique_lock<std::mutex> lock(mutex_);
--count_;
if (count_ == 0) {
cv_.notify_all();
}
}
void Await(uint32_t time_ms = 0) {
std::unique_lock<std::mutex> lock(mutex_);
while (count_ > 0) {
if (time_ms > 0) {
cv_.wait_for(lock, std::chrono::milliseconds(time_ms));
} else {
cv_.wait(lock);
}
}
}
uint32_t GetCount() const {
std::unique_lock<std::mutex> lock(mutex_);
return count_;
}
private:
std::condition_variable cv_;
mutable std::mutex mutex_;
uint32_t count_ = 0;
};
有关条件变量其实有两个坑需要注意,移步这里:使用条件变量的坑你知道吗
基于任务的并发
这块个人认为只需要了解async即可,通过async既可以达到并发的目的,也可以拿到并发执行后的结果。
示例代码:
using namespace std;
int func(int in) { return in + 1; }
int main() {
auto res = std::async(func, 5);
cout << res.get() << endl; // 阻塞直到函数返回
return 0;
}
具体可以看:c++11新特性之线程相关所有知识点
也可以看我利用此种方式写的线程池:C++11线程池
其他
如何使线程休眠?
可以利用std::this_thread和chrono,它俩搭配使得线程休眠很方便,而且休眠时间也很清晰。可不像C语言的sleep,我每次使用C语言的sleep时都会特意去搜索一下,单位究竟是秒还是毫秒。
std::this_thread::sleep_for(std::chrono::milliseconds(10));
线程个数问题
很多人都会纠结线程池开多少个线程效率最高的问题,假设CPU个数为N,有的资料会介绍N个线程效率最高,有的资料会介绍2N个线程效率最高。在<thread>中通过以下函数可以获取CPU的个数:
static unsigned hardware_concurrency() noexcept;
至于需要开多少个线程,个人认为需要根据个性化需求实际测试,你测出来多少个线程性能最高,就开多少个线程。
死锁
死锁的定义可直接维基百科:https://zh.wikipedia.org/wiki/%E6%AD%BB%E9%94%81
至于如何解决死锁,可以看:多线程中如何使用gdb精确定位死锁问题
我关于多线程还有一些建议,推荐大家看这个:
最后,在我学习多线程的过程中,发现了一篇介绍C++11多线程非常详细的博客,也推荐大家看看。