C++多线程使用

多线程编程是计算机领域常用到的一种技术。多线程，顾名思义，指在单个系统里同时启动多个独立的线程，每个线程各干各的，互不影响。显然它的效率要比单线程工作效率高的多。比如，要导入处理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()函数解锁并唤醒其他线程继续争抢锁。