目录
1.简介
多线程程序有着很多优点:
- 快速响应:比如在一个单线程程序中,如果主线程block在一个费时的任务中(比如I/O操作),整个程序会“冻结”住,无法响应外界的输出。通过将交互任务与这个费时的任务独立成两个线程可以解决这个问题。但这并不是主要的用途,因为这种情况通过non-blocking I/O和Unix signal解决,并且带来更小的副作用。
- 更好的性能:在现代计算机中,通常会有多个核心甚至多个CPU,通过多线程可以”更容易“使得多个核心并行(Parallel)执行。理解这句话很重要,很多人天真的以为单线程程序一定是在一个核心上运行,其实现代计算机的instruction pipelining和out-of-order execution打破了这个假设,CPU会对没有依赖关系的指令schedule到不同的核心上,来提高整体性能。
2.线程使用
2.1 demo
#include <iostream>
#include <thread>
#include <future>
using namespace std;
void helloworld()
{
cout << "hello world \n";
}
int main()
{
//开启一个线程
std::thread t(helloworld);
std::cout << "hello world main thread\n";
//线程的终结
t.join();
return 0;
}
2.2 一个简单的应用
- 查看当前线程id: this_thread::get_id()
- 比较单线程和多线程工作的效率(如果工作不太消耗时间,多线程反而比单线程更耗时间)
#include <iostream>
#include <thread>
#include <chrono>
#include <future>
#include <cmath>
#include <vector>
#include <cstdlib>
using namespace std;
double caculate(int v)
{
if (v <= 0) {
return v;
}
//假设这个计算很慢
this_thread::sleep_for(chrono::milliseconds(10));
return sqrt((v * v + sqrt((v - 5) * (v + 2.5)) / 2.0) / v);
}
template<typename Iter, typename Fun>
double visitRange(thread::id id, Iter iterBegin, Iter iterEnd, Fun func)
{
auto curId = this_thread::get_id();
if (id == this_thread::get_id()) {
cout << curId << " hello main thread\n";
}
else {
cout << curId << " hello work thread\n";
}
double v = 0;
for (auto iter = iterBegin; iter != iterEnd; ++iter) {
v += func(*iter);
}
return v;
}
int main()
{
auto mainThreadId = std::this_thread::get_id();
//开启一个线程
std::vector<double> v;
for (int i = 0; i < 1000; i++)
{
v.push_back(rand());
}
cout << v.size() << endl;
double value = 0.0;
auto st = clock();
for (auto & info : v)
{
value += caculate(info);
}
auto ed = clock();
cout << "single thread: " << value << " " << ed - st << "time" << endl;
//下面用多线程来进行
auto iterMid = v.begin() + (v.size() / 2); // 指向整个vector一半部分
//计算后半部分
double anotherv = 0.0;
auto iterEnd = v.end();
st = clock();
std::thread s([&anotherv, mainThreadId, iterMid, iterEnd]() { // lambda
anotherv = visitRange(mainThreadId, iterMid, iterEnd, caculate);
});
// 计算前半部分
auto halfv = visitRange(mainThreadId, v.begin(), iterMid, caculate);
//关闭线程
s.join();
ed = clock();
cout << "multi thread: " << (halfv + anotherv) << " " << ed - st << "time" << endl;
return 0;
}
3.竞争条件与互斥锁
3.1竞争条件
并发代码中最常见的错误之一就是竞争条件(race condition)。而其中最常见的就是数据竞争(data race),从整体上来看,所有线程之间共享数据的问题,都是修改数据导致的,如果所有的共享数据都是只读的,就不会发生问题。但是这是不可能的,大部分共享数据都是要被修改的。
而c++中常见的 cout
就是一个共享资源,如果在多个线程同时执行cout
,你会发发现很奇怪的问题:
#include <iostream>
#include <thread>
#include <string>
using namespace std;
// 普通函数 无参
void function_1() {
for(int i=0; i>-100; i--)
cout << "From t1: " << i << endl;
}
int main()
{
std::thread t1(function_1);
for(int i=0; i<100; i++)
cout << "From main: " << i << endl;
t1.join();
return 0;
}
你有很大的几率发现打印会出现类似于From t1: From main: 64
这样奇怪的打印结果。cout
是基于流的,会先将你要打印的内容放入缓冲区,可能刚刚一个线程刚刚放入From t1:
,另一个线程就执行了,导致输出变乱。而c语言中的printf
不会发生这个问题。
3.2 使用互斥元保护共享数据
3.2.1 mutex-互斥锁
应注意:同一时刻,只能有一个线程持有该锁
当A线程对某个全局变量加锁访问,B在访问前尝试加锁,拿不到锁,B阻塞。C线程不去加锁,而直接访问该全局变量,依然能够访问,但会出现数据混乱。
所以,互斥锁实质上是操作系统提供的一把“建议锁”(又称“协同锁”),建议程序中有多线程访问共享资源的时候使用该机制。但,并没有强制限定。
因此,即使有了mutex,如果有线程不按规则来访问数据,依然会造成数据混乱。
加锁与解锁
lock与unlock:
lock尝试加锁,如果加锁不成功,线程阻塞,阻塞到持有该互斥量的其他线程解锁为止。
unlock主动解锁函数,同时将阻塞在该锁上的所有线程全部唤醒,至于哪个线程先被唤醒,取决于优先级、调度。默认:先阻塞、先唤醒。
例如:T1 T2 T3 T4 使用一把mutex锁。T1加锁成功,其他线程均阻塞,直至T1解锁。T1解锁后,T2 T3 T4均被唤醒,并自动再次尝试加锁。
可假想mutex锁 init成功初值为1。 lock 功能是将mutex–。 unlock将mutex++
上一节中的问题的解决办法就是要对cout
这个共享资源进行保护。在c++中,可以使用互斥锁std::mutex
进行资源保护,头文件是#include <mutex>
,共有两种操作:锁定(lock)与解锁(unlock)。将cout
重新封装成一个线程安全的函数:
#include <iostream>
#include <thread>
#include <string>
#include <mutex>
using namespace std;
std::mutex mu;
// 使用锁保护
void shared_print(string msg, int id) {
mu.lock(); // 上锁
cout << msg << id << endl;
mu.unlock(); // 解锁
}
void function_1() {
for(int i=0; i>-100; i--)
shared_print(string("From t1: "), i);
}
int main()
{
std::thread t1(function_1);
for(int i=0; i<100; i++)
shared_print(string("From main: "), i);
t1.join();
return 0;
}
3.2.2 lock_guard
修改完之后,运行可以发现打印没有问题了。但是还有一个隐藏着的问题,如果mu.lock()
和mu.unlock()
之间的语句发生了异常,会发生什么?unlock()
语句没有机会执行!导致导致mu
一直处于锁着的状态,其他使用shared_print()
函数的线程就会阻塞。
解决这个问题也很简单,使用c++
中常见的RAII技术,即获取资源即 初始化(Resource Acquisition Is Initialization) 技术,这是c++
中管理资源的常用方式。简单的说就是在类的构造函数中创建资源,在析构函数中释放资源,因为就算发生了异常,c++
也能保证类的析构函数能够执行。我们不需要自己写个类包装mutex
,c++
库已经提供了std::lock_guard
类模板,使用方法如下:
void shared_print(string msg, int id) {
//构造的时候帮忙上锁,析构的时候释放锁
std::lock_guard<std::mutex> guard(mu);
//mu.lock(); // 上锁
cout << msg << id << endl;
//mu.unlock(); // 解锁
}
可以实现自己的std::lock_guard
,类似这样
class MutexLockGuard
{
public:
explicit MutexLockGuard(std::mutex& mutex)
: mutex_(mutex)
{
mutex_.lock();
}
~MutexLockGuard()
{
mutex_.unlock();
}
private:
std::mutex& mutex_;
};
3.2.3 unique_lock
互斥锁保证了线程间的同步,但是却将并行操作变成了串行操作,这对性能有很大的影响,所以我们要尽可能的减小锁定的区域,也就是使用细粒度锁。
这一点lock_guard
做的不好,不够灵活,lock_guard
只能保证在析构的时候执行解锁操作,lock_guard
本身并没有提供加锁和解锁的接口,但是有些时候会有这种需求。看下面的例子。
class LogFile {
std::mutex _mu;
ofstream f;
public:
LogFile() {
f.open("log.txt");
}
~LogFile() {
f.close();
}
void shared_print(string msg, int id) {
{
std::lock_guard<std::mutex> guard(_mu);
//do something 1
}
//do something 2
{
std::lock_guard<std::mutex> guard(_mu);
// do something 3
f << msg << id << endl;
cout << msg << id << endl;
}
}
};
上面的代码中,一个函数内部有两段代码需要进行保护,这个时候使用lock_guard
就需要创建两个局部对象来管理同一个互斥锁(其实也可以只创建一个,但是锁的力度太大,效率不行),修改方法是使用unique_lock
。它提供了lock()
和unlock()
接口,能记录现在处于上锁还是没上锁状态,在析构的时候,会根据当前状态来决定是否要进行解锁(lock_guard
就一定会解锁)。上面的代码修改如下:
class LogFile {
std::mutex _mu;
ofstream f;
public:
LogFile() {
f.open("log.txt");
}
~LogFile() {
f.close();
}
void shared_print(string msg, int id) {
std::unique_lock<std::mutex> guard(_mu);
//do something 1
guard.unlock(); //临时解锁
//do something 2
guard.lock(); //继续上锁
// do something 3
f << msg << id << endl;
cout << msg << id << endl;
// 结束时析构guard会临时解锁
// 这句话可要可不要,不写,析构的时候也会自动执行
// guard.ulock();
}
};
上面的代码可以看到,在无需加锁的操作时,可以先临时释放锁,然后需要继续保护的时候,可以继续上锁,这样就无需重复的实例化lock_guard
对象,还能减少锁的区域。同样,可以使用std::defer_lock
设置初始化的时候不进行默认的上锁操作:
void shared_print(string msg, int id) {
std::unique_lock<std::mutex> guard(_mu, std::defer_lock);
//do something 1
guard.lock();
// do something protected
guard.unlock(); //临时解锁
//do something 2
guard.lock(); //继续上锁
// do something 3
f << msg << id << endl;
cout << msg << id << endl;
// 结束时析构guard会临时解锁
}
这样使用起来就比lock_guard
更加灵活!然后这也是有代价的,因为它内部需要维护锁的状态,所以效率要比lock_guard
低一点,在lock_guard
能解决问题的时候,就是用lock_guard
,反之,使用unique_lock
。
参考:
- https://www.jianshu.com/p/34d219380d90
- https://www.cnblogs.com/douzujun/p/10810506.html
- https://blog.csdn.net/qq_39736982/article/details/82348672