C++ OpenMP、TBB库的简单使用

1.OpenMP的简单使用

OpenMP可以用来并行计算for循环，提高程序运行速度。

首先要打开OpenMP支持：“配置属性”——“C/C++”——“语言”——“1.OpenMP支持”后选择“是”。

omp_get_num_procs()                //获取系统中处理器的个数
omp_set_num_threads(num_count)    //设置线程数
omp_get_thread_num()            //获取当前线程的Id号

用法1：

#pragma omp parallel
{
    //每个线程都会执行大括号里的代码
    //并行的线程数由系统决定
}
//指定执行代码块的线程数
omp_set_num_threads(4);//设置线程数，需要包含头文件<omp.h>
#pragma omp parallel
或者
#pragma omp parallel num_threads(4)//在parallel后直接增加线程子句
{
    //执行该代码块的线程数为4
}

例子1：

#include <iostream>
#include "omp.h"
using namespace std;
int main()
{
    omp_set_num_threads(4);//设置线程数
#pragma omp parallel
    {
        //cout << "hello ,threads" << omp_get_thread_num() << endl;//cout打印格式混乱
        printf("I am Thread %d\n", omp_get_thread_num());
    }
    system("pause");
    return 0;
}

从运行结果可以看出，各线程的先后顺序不确定（0是主线程）。

用法2：

#pragma omp parallel for num_threads(4)
for( ; ; )
{
    //并行计算for循环里的代码块，循环退出，并行结束
}
或
#pragma omp parallel
{
    #pragma omp for
    for()
    {
        //并行运行该代码块
    }
}

例子2.

#include <iostream>
#include "omp.h"
using namespace std;
int main()
{
#pragma omp parallel for num_threads(4)//只需要多加这一行代码
    for (int i = 0; i < 20; i++)
    {
        //cout << "hello ,threads :" << omp_get_thread_num() << endl;
        printf("i = %d, I am Thread %d\n", i, omp_get_thread_num());
    }
    system("pause");
    return 0;
}

运行结果：

for循环执行的先后顺序不能保证，因此for循环里的内容必须不存在依赖关系。for循环中不能有break和return退出出口。

数据同步问题：

例3.

#include <iostream>
#include "omp.h"
using namespace std;
int main()
{
    int n = 10000;
    int sum = 0;
    omp_set_num_threads(4);
#pragma omp parallel
    {
#pragma omp for 
        for (int i = 0; i < n; i++) 
        {
            sum += 1;
        }
    }
    cout << " sum = " << sum << endl;
    system("pause");
    return 0;
}

正确答案应为10000，但运行时每次得到的结果都不同，这是因为sum变量是每个线程共享的，多个线程同时对sum操作，会因为数据同步问题发生错误。

解决方法：

方法一：对操作共享变量的代码段做同步标识

int main()
{
int n = 10000;
    int sum = 0;
    omp_set_num_threads(4);
#pragma omp parallel
    {
#pragma omp for 
        for (int i = 0; i < n; i++) 
        {
#pragma omp critical    //critical用在一段代码临界区之前，保证每次只有一个OpenMP线程进入
            sum += 1;
        }
    }
}

方法二：每个线程拷贝一份sum变量，退出并行块时再把各个线程的sum相加

#pragma omp parallel
    {
#pragma omp for reduction(+:sum) 
        for (int i = 0; i < n; i++) {
            {
                sum += 1;
            }
        }
    }

2.TBB库的简单使用
TBB（Thread Building Blocks）是英特尔发布的一个C++标准库。

1.配置

设置环境变量：将tbb中bin文件夹下的vc12(与VS2013对应)的路径添加到环境变量，然后重启电脑。

将include文件夹所在路径添加到包含目录，将lib文件夹所在路径添加到库目录。

2.parallel_for的用法

包含头文件#include ”tbb/parallel_for.h“

**parallel_for(range, body, partitioner)提供了并行迭代的泛型形式。它表示在区域的每个值，并行执行body。partitioner选项指定了分割策略。

例子：

#include <iostream>
#include <tbb/tbb.h>
using namespace std;
using namespace tbb;
typedef vector<int>::iterator IntVecIt;
struct body
{
    //blocked_range<T>是ttb库模板类，声明一个一维迭代空间
    //parallel_for要求实体对象的operator()声明为const
    void operator()(const blocked_range<IntVecIt>&r)const//重载()运算符
    {
        for (auto i = r.begin(); i != r.end(); i++)
            cout << *i << ' ';
    }
};
int main()
{
    vector<int> vec;
    for (int i = 0; i<10; i++)
        vec.push_back(i);
    parallel_for(blocked_range< IntVecIt>(vec.begin(), vec.end()), body());
    system("pause");
    return 0;
}

 使用lambda表达式，上面的例子可以写为

int main()
{
    vector<int> vec;
    for (int i = 0; i<10; i++)
        vec.push_back(i);
    parallel_for((blocked_range< IntVecIt>(vec.begin(), vec.end())), 
                 [&](const blocked_range<IntVecIt>&r){
        for (auto i = r.begin(); i != r.end(); i++)
            cout << *i << " ";
    }
    );
    system("pause");
    return 0;
}

为了更紧凑，对于在一个整形的连续区域执行并行循环，TBB有对应形式的 parallel_for 。表达式 parallel_for(first,last,step,f) 就像 for(auto i = first; i< last; i+= step) f(i)

3.运行时间对比

#include <iostream>
#include <time.h>
void test()
{
    int a = 0;
    for (int i = 0; i<100000000; i++)
        a++;
}
int main()
{
    clock_t t1 = clock();
    //OpenMP多线程
#pragma omp parallel for
    for (int i = 0; i < 8; i++)
        test();
    clock_t t2 = clock();
    std::cout << "time: " << t2 - t1 << std::endl;//打印运行时间
    system("pause");
}
//tbb多线程
parallel_for(blocked_range<size_t>(0, 8), [&](const blocked_range<size_t> &i){
            test();
    });

对于上面这个例子，调用8次test函数，不使用多线程的运行时间为1333ms，使用OpenMP多线程后的运行时间为196ms，使用tbb多线程后的运行时间为203ms。可以看出使用OpenMP和tbb后程序运行时间加快了好几倍。

3.thread多线程的简单使用
包含头文件#include

创建多线程

void func01()
{
    //to do something
}

void func02（int num）
{
    //to do something
}
int main()
{
  thread t1(func01);//给函数func创建子线程
  t1.join();//阻塞主线程（main函数的线程称为主线程）
  //t1.detach();//使子线程从主线程中分离，不会阻塞主线程
  //带参子线程
  thread t2(func02,5);  t2.join();
}

//线程互斥
#include <iostream>
#include <thread>
#include <Windows.h>
#include <mutex>// mutex类的使用需要包含该头文件 
using namespace std; 
mutex mu;  //线程互斥对象
 
int totalNum = 100;
 
void thread01()
{
    while (totalNum > 0)
    {
        mu.lock(); //同步数据锁
        cout << totalNum << endl;
        totalNum--;
        Sleep(100);
        mu.unlock();  //解除锁定
    }
}
void thread02()
{
    while (totalNum > 0)
    {
        mu.lock();
        cout << totalNum << endl;
        totalNum--;
        Sleep(100);
        mu.unlock();
    }
}
 
int main()
{
    thread task01(thread01);
    thread task02(thread02);
    task01.detach();
    task02.detach();
    system("pause");
}

//在类外部为类的成员函数创建子线程
class Test
{
public:
    void add(int a,int b,int &c)//要改变c的值，用引用接收
    {
        c=a+b;
    }
private:
    int a=1;
    int b=2;
    int c=0;
};
int main()
{
    Test T;
    //需要传递对象T，要改变主线程中的值，则需要传递引用，thread中用ref，用&会报错
    thread t1(&Test::add,&T,T.a,T.b,ref(T.c));
    cout <<T.c<<endl;
}

4.lambda表达式

lambda表达式是C++11引入的新特性，功能：定义并创建匿名函数对象，以简化编程工作。

语法：[捕获子句]（参数列表）mutable关键字 异常关键字 —>返回类型 {函数体} （实参）

 

1. 捕获子句（[]是lambda表达式的先导符号，告诉编译器下面是lambda表达式）

2. 参数列表（可选）

3. mutable关键字（可选）

4. 异常关键字（可选）

5. 返回类型（可选）（省略返回类型时，->也要省略）

6. lambda函数体

int num = [](int num)->int{return ++num; }(10);//10是传递的实参
cout << num << endl;//打印结果为11

如果想在lambda表达式内访问外部的数据，可使用以下方式传递变量：

[=]//值传递所有变量  
[&]//引用所有变量  
[var]//值传递变量  
[&var]//引用传递变量 

例子

int num = 10;
[=]()mutable            //当使用mutable关键字时，可以对值传递的变量进行“写”操作
{cout << ++num << endl;}();//此处的小括号不能省略
cout << num << endl;    //调用lambda后num任然是10(值传递)

//写成函数的形式
auto fun = [=](int a)mutable ->int {return ++a;};//auto关键字自动推断lambda表达式的类型
cout << fun(num) << endl;

2.

如果想在lambda表达式内访问外部的数据，可使用以下方式传递变量：

```c++
[=]//值传递所有变量  
[&]//引用所有变量  
[var]//值传递变量  
[&var]//引用传递变量 

例子

int num = 10;
[=]()mutable            //当使用mutable关键字时，可以对值传递的变量进行“写”操作
{cout << ++num << endl;}();//此处的小括号不能省略
cout << num << endl;    //调用lambda后num任然是10(值传递)

//写成函数的形式
auto fun = [=](int a)mutable ->int {return ++a;};//auto关键字自动推断lambda表达式的类型
cout << fun(num) << endl;