在上一节中我们讲的是一个常用的并行化编程方法（for的并行化），其实它只是并行化编程的一个特例，只是它的地位较高，或者说它比其它并行化更重要。在本节中我们将讨论一般的并行区域编程。

并行区域的编译指导语句一般格式

    一般格式：#pragma omp parallel [clause[clause]…]{…}

    其中{…}中为每个线程都执行的部分，在parallel后面可以跟随一些指导子句，例如：threadprivate、copyin等，本节中将以一些实例来依次讲解这些语句的作用。

    时刻记住，主线程就是0号线程，这个与for不同，另外private、firstprivate、lastprivate是for并行的东西最好不要拿来比较，尽管我在本文里比较了，但是我还是感觉有些头痛啊。

例子实例

例1 不带指导子句的并行程序

      #pragma omp parallel指示它下面的一对大括号内的程序复制执行threads个数次。默默人情况下，所有并行区域中的变量是共享的，所以一定要谨防数据竞争的发生。

#include 
#include "omp.h" 
int main(int argc, char* argv[]) 
{ 
    #pragma omp parallel 
    for (int i = 0; i < 2; i++) 
    { 
        printf("Hello World! i = %d, Thread Num = %d/n", i, omp_get_thread_num()); 
    } 
    return 0; 
}

图1、例1的执行结果

例1的执行结果可以看出四个线程分别执行了一遍#pragma omp parallel下面的语句，想想一下如果使用#pragma omp parallel for会是什么样的结果。

例2 使用threadprivate子句

     此命令表示所有并行线程使用指定变量为各自私有的，能被定义为各线程私有变量的变量只能是静态变量和全局变量。看下面的程序，希望你能发现，其实#pragma omp threadprivate()是可以单独使用的。

    说明一下：被定义为threadprivate的变量对于每个线程永远是活的，你在任何时候再次重新启动各线程时，前面并行时最后得到的变量值仍然保留他的值，如果你用private代替threadprivate，那么你重新启动各线程时，变量的值仍然为0。如果你不初始化要声明为private的变量，那么在串行程序中，你就不能再没有任何赋值的情况下使用它，否则会引起异常的（VS2010）。而且private不能单独像threadprivate那样定义某个变量。

    如果你使用另外#pragma omp threadprivate(var)，那么var必须是静态变量或者全局变量，如过你在并行开始之前并没有初始化赋值，那么每个线程中默认var的值为0.如果你赋了初值，那么每个线程中var的初值都是你赋的初始值。其中主线程就是0号线程。如果你使用了#pragma omp private(var)，那么var并不会赋初值，即使你在并行之前赋了初值。想想原先#pragma omp parallel for 的firstprivate就知道了，呵呵。在#pragma omp parallel中可以使用lastprivate，但是不能使用lastprivate，使用firstprivate(var)后，串行部分的var并不是并行时0号线程的var值，它仍未你原先赋的初值。是不是很绕啊？呵呵，你可以这样理解，使用firstprivate和private的并行都不是纯真的联合主线程的编号。这样就混不了了。

#include 
#include "omp.h" 
int sum = 0; 
#pragma omp threadprivate(sum) 
int main(int argc, char* argv[]) 
{ 
    #pragma omp parallel 
    { 
        sum += omp_get_thread_num(); 
        printf("parallel sum = %d; thread num = %d/n", sum, omp_get_thread_num()); 
    } 
    printf("/nserial sum = %d; thread num = %d/n/n", sum, omp_get_thread_num()); 
    #pragma omp parallel 
    printf("parallel sum = %d; thread num = %d/n", sum, omp_get_thread_num()); 
    return 0; 
}

图2、例2执行结果

threadprivate指定了sum这个变量属于每个线程，每个线程都有自己的sum变量，各个线程结束后他们的sum变量并没有注销，在此啊执行时，他们各自的sum值还保持原值。

例3 使用copyin

指定主线程的值拷贝到各线程中去，下面的例子中，sum是每个线程独有的，并且初始值都是0，main中第一行代码将0号线程的sum值赋为100，其它线程的sum值并没有变。

#include <stdio.h>
#include "omp.h" 
int sum; 
#pragma omp threadprivate(sum) 
int main(int argc, char* argv[]) 
{ 
    sum = 100; 
    #pragma omp parallel copyin(sum) 
    { 
        sum += omp_get_thread_num(); 
        printf("parallel sum = %d; thread num = %d/n", sum, omp_get_thread_num()); 
    } 
    printf("/nserial sum = %d; thread num = %d/n/n", sum, omp_get_thread_num()); 
    #pragma omp parallel 
    printf("parallel sum = %d; thread num = %d/n", sum, omp_get_thread_num()); 
    return 0; 
}

图3、例3的执行结果

图4、例3中将copyin(sum)删除后的执行结果

通过以上图3、4可以看出copyin的用处是初始化各个线程中自己私有的sum变量。实际上定义sum为全局量时的初始值就是原sum值（如果不使用copyin的话）。

我想了想threadprivate和private以及firstprivate的区别。写出来大家讨论下。

1、threadprivate，限制变量为每个线程私有。被限制的变量必须具有全局特性，他的生命周期是整个程序。

2、private，可以限制变量为每个线程私有，但是他的生命周期是一次启动并行计算。

3、firstprivate，可以将穿行程序中的初值带进每个线程，变量为每个线程私有。生命周期与private相同。

4、还有个lastprivate的问题，他并不能在区域并行中使用。

大家实验把。。。

编译指导语句：

    一般格式：

    #pragma omp parallel for [clause[clause…]]

    for(index = first; qualification; index_expr)

    {…}

    第一句中[]的部分是可选的，由自己的程序并行特点而定。大家先不要把精力放到这里面。后面的文章中会继续讲解的。

并行化for的编写规则

    1、index的值必须是整数，一个简单的for形式：for(int i = start; i < end; i++){…} 。

    2、start和end可以是任意的数值表达式，但是它在并行化的执行过程中值不能改变，也就是说在for并行化执行之前，编译器必须事先知道你的程序执行多少次，因为编译器要把这些计算分配到不同的线程中执行。

    3、循环语句只能是单入口但出口的。这里只要你避免使用跳转语句就行了。具体说就是不能使用goto、break、return。但是可以使用continue，因为它并不会减少循环次数。另外exit语句也是可以用的，因为它的能力太大，他一来，程序就结束了。

例子讲解

例1、for循环并行:

#include 
#include "omp.h" 
int main(int argc, char* argv[]) 
{ 
    int i; 
    #pragma omp parallel for 
    for (i = 0; i < 12; i++) 
    {        printf("i = %d  %d/n", i, omp_get_thread_num());    } 
    return 0; 
}

例1的执行结果如图1所示：

图1、例1的执行结果

从结果中可以看出 i 属于{0,1,2}时由0号线程执行，i 属于{3,4,5}时由1号线程执行，i 属于{6,7,8}时由2号线程执行，i 属于{9,10,11}时由3号线程执行。omp_get_thread_num()这个函数通过执行结果大家也知道了，他返回每个线程的编号。

并行编译子句

    openMP中有多种并行化子句，这些子句都是为控制循环并行化编译而设定的，这里我们主要关注数据作用域子句，这里的数据作用域是指各个线程是否对某一变量有权访问。shared子句用来标记变量在各个线程之间是共享的，private子句标记变量在各个线程之间是私有的，实际上它会在在每个线程中保存一个副本。默认情况下，并行执行的变量是共享的。至于其它编译子句将在后面的文章中介绍。

用实例讲解数据作用域子句

实际上我很难想到一个综合的例子来讲解这种子句的限制异同，所以我写了几个例子。

例2、private

#include
#include "omp.h"
int main(int argc, char* argv[])
{
    float x = 4.3f;
    int i;
    #pragma omp parallel for private(x)
    for (i = 0; i < 12; i++)
    {
        x = 0;
        printf("parallel x = %.1f, thread nummber:%d/n", x, omp_get_thread_num());
    }
    printf("/nserial   x = %.1f, thread nummber:%d/n", x, omp_get_thread_num());
    return 0;
}

图2、例2执行结果

例3 firstprivate(var)：指定var在每个线程中都有一个副本，并且var的初始值在并行执行开始之前定义，每个并行线程的var的副本初值就是串行时定义的初始值。程序结束后串行程序中的var值并不会改变。

#include 
#include "omp.h" 
int main(int argc, char* argv[]) 
{ 
    float x = 4.3f; 
    int i; 
    #pragma omp parallel for firstprivate(x) 
    for (i = 0; i < 12; i++) 
    { 
        x += 1.0f; 
        printf("parallel x = %.1f, thread nummber:%d/n", x, omp_get_thread_num());        
    } 
    printf("/nserial   x = %.1f, thread nummber:%d/n", x, omp_get_thread_num()); 
    return 0; 
}

图3、例3的执行结果

例4 lastprivate(var):指定最后多线程执行完后原串行循环最后一次var的值带到主线程（串行部分）

#include 
#include "omp.h" 
int main(int argc, char* argv[]) 
{ 
    float x = 4.3f; 
    int i; 
    #pragma omp parallel for lastprivate(x) 
    for (i = 0; i < 12; i++) 
    {        
        x = 0.0f; 
        printf("parallel x = %.1f, thread nummber:%d/n", x, omp_get_thread_num());        
    } 
    printf("/nserial   x = %.1f, thread nummber:%d/n", x, omp_get_thread_num()); 
    return 0; 
}

图4、例4的执行结果

例5 firstprivate与lastprivate联用，很奇怪openMP很多情况下是不允许某个变量被指定两次规则的，他俩却可以，呵呵，而且配合效果还不错。

#include 
#include "omp.h" 
int main(int argc, char* argv[]) 
{ 
    float x = 4.3f; 
    int i; 
    #pragma omp parallel for firstprivate(x) lastprivate(x) 
    for (i = 0; i < 12; i++) 
    {        
        x += (float)omp_get_thread_num(); 
        printf("parallel x = %.1f, thread nummber:%d/n", x, omp_get_thread_num());        
    } 
    printf("/nserial   x = %.1f, thread nummber:%d/n", x, omp_get_thread_num()); 
    return 0; 
}

图5、例5的执行结果

    从上面的例2、3的程序中可以看出例2中每个线程中x都是私有的，它属于每个线程，在主线程的定义并不能带入到各个线程中，使用firstprivate后，x在主线程的初始值可以带到各个线程中，在图3可以看出每个线程x的输出结果实际是相同的，但是在并行执行结束后，主线程中的x值仍然为4.3。从例4的执行结果可以看出最后x的值带出到了主线程中，这个x值到底是哪个线程中的哪？答案是最后一句x赋值后的值，哪个线程执行完的最晚就是哪个x的值。例5显示firstprivate与lastprivate联合使用的执行结果。

例6 reduction规约操作，

    执行reduction的变量要特别注意，以reduction(+:sum)为例。

    第一种情况：sum为局部变量。这是你必须为sum在串行程序中赋初值，sum 被设置为每个线程私有，先各自执行完算出各自的sum值，最后主线程会将 《线程数+1》个sum变量规约，比如你num_thread(4),在开始并行执行之前你对规约变量赋初值为10，并行时假设每个线程算的的sum值为1，那么最终sum带到串行程序中的变量值为14（串行的10+四个线程的1）。

    第二种情况：sum为全局变量。这是你不必为sum赋初始值，因为此时默认串行的sum值为0，进入每个线程的sum值也是0，规约时仍然是将《线程数+1》个sum值相加，因为你并没有对全局的sum赋初值，所以最后规约的结果看着像是只有各线程的sum参加了规约操作。其实当你将全局的sum赋初值时，你会发现最后规约的sum值又多加了全局变量sum的串行程序结果。

    重要提醒：不管你怎样设计sum的串行声明形式，只要他在被定义为规约变量，每次进入并行线程的sum值都是0；

    也许你想把每个并行线程的sum值初始化成一个非0的值，然后再各自线程中在使用，那么我可以告诉你，别想了（至少我没有做到）。因为我规约sum值，如果这个规约有意义你的每个线程应该是各自独立未回各自的sum的，那么这个初始值使用0就已经非常好了，因为各自的sum计算如果结果一样，你为何不直接用一句乘法哪（线程数*一个线程计算的sum值）。

#include 
#include "omp.h" 
int main(int argc, char* argv[]) 
{ 
    float x = 0.0f; 
    int i; 
    float sum = 0.0f; 
#pragma omp parallel for private(x) reduction(+:sum) 
    for (i = 0; i < 12; i++) 
    {        
        x = (float)omp_get_thread_num(); 
        sum += x; 
        printf("parallel sum = %.1f, thread nummber:%d/n", sum, omp_get_thread_num());        
    } 
    printf("/nserial   sum = %.1f, thread nummber:%d/n", sum, omp_get_thread_num()); 
    return 0; 
}

图6、例6执行结果

    在例6中我使用了reduction(+:sum)，这表示每个线程对sum这个共享变量执行加操作时其它任何线程不能对它进行加操作，实际上我们这样理解是有偏差的，真正的机理在执行结果中不难看出，实际每个线程都拷贝了一个sum的副本，先在自己执行时加完sum，等所有线程都执行结束后，主线程再将每个线程的sum副本的值加起来返回给主线程中sum。

小结

    本节主要讲述了for语句的并行化。现在为止大家应该可以熟练使用for并行化了。文章中可能还有些不全面的地方，热切期望各位读者能给出批评和指正，期待中……

    并行化编程一般可以理解为多个线程的创建和并行化编程，并行化编程的东西很多，但他们都会有两个必须的规定：1、程序执行模型。2、存储模型。

    程序执行模型，他规定了并行化线程的执行方式，规则，或者说逻辑结构。openMP的执行采用了Fork-Join模型。主线程在执行过程中遇到要并行处理的部分，根据openMP的编译指导语句来创建，执行多个线程，创建的线程个数一般与计算机的核心数成正比，可以通过添加一个环境变量（OMP_NUM_THREADS）来规定创建线程的个数，注意环境变量添加后要注销或者重启系统才会生效。

图1 omp程序执行模型

    存储模型，omp针对的是一个计算机或者分布式计算机的并行，在一台计算机上他采用共享存储的方式，多个线程共享一块进程的内存资源。

    下面先写个程序例子，能让大家有个初步认识。这个程序是在VS2008中编译的，项目类型为Win32ConsoleApplication。

例1、并行HelloWorld程序:

#include <stdio.h>
#include "omp.h" 
int main(int argc, char* argv[]) 
{ 
    printf("Hello World! Serial Begin./n"); 
    #pragma omp parallel    //开始并行执行 
    {        printf("Hello World! Parallel/n");    } 
    printf("Hello World! Serial again./n"); 
    return 0; 
}

此程序编译之前，还需要你对你的编译器项目属性设置一下。这里我们以VS2008为例，首先设置项目支持openMP。右击项目->属性->C/C++->语言->openMP支持修改为是，如图2所示，然后代码生成修改为多线程调试，如图3所示。执行结果如图4所示。

图2、添加openMP支持

图3、多线程调试支持

图4、执行结果

以上程序我并没有设置环境变量，因为我的计算机是双核的，所以他的并行部分输出了两行Hello World！ Parallel，这说明他有两个线程执行并行部分，每个线程完全执行了相同的一段程序。我们在设置一下环境变量后在执行一下。顺便说明一下怎样设置环境变量。

计算机右击-》属性-》高级-》环境变量-》系统变量-》新建。。。如图5所示。

图5、Win7环境下设置环境变量

设置完环境后，注销或重启系统后，再次执行例1的程序后得到的结果中Hello World！ Parallel 将被执行四遍。因为你已经设置了四个线程了。

到现在为止，大家可以模仿着例1写几个小程序了，可是还有一句话大家可能还不大明白吧，#pragma omp parallel这句话标记{}中的程序将在OMP_NUM_THREADS个线程中执行。

在下面的几篇文章中我将继续讲解openMP编程的基础知识。欢迎继续关注。