多线程编程是计算机领域常用到的一种技术。多线程,顾名思义,指在单个系统里同时启动多个独立的线程,每个线程各干各的,互不影响。显然它的效率要比单线程工作效率高的多。比如,要导入处理10万条数据,一个线程既负责导入数据又兼具处理数据的任务,是一个串行处理的流程,运行效率低下。如果用多个线程工作,部分线程负责导入数据,另一部分线程负责处理数据,实现并行处理,运行效率可以提升数倍。
自从c++11开始,c++开始在语言级别上支持多线程,为多线程编程提供了极大的便利。
1. Hello world
#include <iostream>
#include <thread>
using namespace std;
void task(){
cout << "hello world" << endl;
}
int main(){
thread th(task);
th.join();
return 0;
}
这个是c++多线程的hello world代码。我们创建一个std::thread 对象即创建子线程,该线程将会调用task函数。th.join() 表示启动该线程,并阻塞main 主线程,main 主线程等待子线程执行完毕才退出程序。
2. 互斥锁mutex
当我们多个线程对同一个变量进行操作的时候,不可避免会遭到两个线程的互相争抢,增加了许多不确定性。尤其在运行复杂的代码时,容易造成数据的不准确。因此,引入互斥锁mutex的概念,比如线程1抢到控制权后,加锁保护,阻塞其他线程;线程1运行完之后,解锁,其他线程方可继续运行。
#include <iostream>
#include <thread>
#include <mutex>
using namespace std;
int a = 0;
mutex mtx;
void task1(){
for(int i=0; i<100; i++){
mtx.lock();
a++;
cout << "we now add:" << a << endl;
mtx.unlock();
}
}
void task2(){
for(int i=0; i<100; i++){
mtx.lock();
a--;
cout << "we now subtract:" << a << endl;
mtx.unlock();
}
}
int main(){
thread th1(task1);
thread th2(task2);
th1.join();
th2.join();
cout << "a:" << a << endl;
}
C++当中用到的一个类是mutex,这个中文就是互斥量的意思,顾名思义,就是一个时刻只能有一个访问。创建一个mutex对象mtx 。在需要加锁的地方,调用mtx.lock() ,运行完之后记得要解锁mtx.unlock() 。
3. lock_guard和unique_lock
为了防止使用mutex加锁之后忘记解锁了,c++专门提供了lock_guard类,声明一个局部的lock_guard对象,在其构造函数中进行加锁,在其析构函数中进行解锁。当控制流离开lock_guard对象的作用域时,lock_guard析构并解锁。
#include<iostream>
#include<thread>
#include<mutex>
using namespace std;
mutex m;
void proc1(int a)
{
lock_guard<mutex> g1(m);//用此语句替换了m.lock();lock_guard传入一个互斥量,此时调用了lock_guard的构造函数,申请锁定m
cout << "proc1函数正在改写a" << endl;
cout << "原始a为" << a << endl;
cout << "现在a为" << a + 2 << endl;
} //此时不需要写m.unlock(),g1出了作用域被释放,自动调用析构函数,于是m被解锁
void proc2(int a)
{
{
lock_guard<mutex> g2(m);
cout << "proc2函数正在改写a" << endl;
cout << "原始a为" << a << endl;
cout << "现在a为" << a + 1 << endl;
}
//通过使用{}来调整作用域范围,此时m被解锁
cout << "作用域外的内容3" << endl;
cout << "作用域外的内容4" << endl;
cout << "作用域外的内容5" << endl;
}
int main()
{
int a = 0;
thread t1(proc1, a);
t1.join();
thread t2(proc2, a);
t2.join();
return 0;
}
它的特点如下:
- 创建即加锁,作用域结束自动析构并解锁,无需手工解锁;
- 不能中途解锁,必须等作用域结束才解锁。
unique_lock是lock_guard的升级版,它具有lock_guard的所有功能,使用起来更加灵活方便,能应对更复杂的加锁解锁需要。但是unique_lock内部会维护一个锁的状态,效率要差一点,内存占用会多一点。特点如下:
- 可以中途随时加锁解锁;
- 作用域规则同 lock_grard,析构时自动释放锁;
4. 条件变量condition_variable
c++11中,用条件变量可以实现多个线程间的同步操作;当条件不满足时,相关线程被一直阻塞,直到某种条件出现,这些线程才会被唤醒。一般要用到wait() ,notify_one() 等函数,实现多个线程之间阻塞、等待、通知等操作。
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
using namespace std;
mutex mtx;
condition_variable cv;
int a = 0;
void print_even(){
for(int i=0; i<10; i++){
unique_lock<mutex> locker(mtx);
cv.wait(locker, [&](){
return a%2==0;
});
cout << "even:" << a << endl;
a++;
cv.notify_one();
}
}
void print_odd(){
for(int i=0; i<10; i++){
unique_lock<mutex> locker(mtx);
cv.wait(locker, [&](){
return a%2!=0;
});
cout << "odd:" << a << endl;
a++;
cv.notify_one();
}
}
int main(){
thread th1(print_even);
thread th2(print_odd);
th1.join();
th2.join();
}
上面的代码利用多线程实现奇偶数的打印。wait() 函数阻塞当前线程并解锁,争抢互斥锁。当打印偶数线程抢到互斥锁后,判断a能否被2整除,如果不能被2整除,则交出互斥锁,继续争抢;如果能被2整除,则抢锁成功,获得控制权,其他线程阻塞,该线程向下执行。执行完之后,notify_one() 函数解锁并唤醒其他线程继续争抢锁。
|