比如在一个双核CPU上，n=64，最终会以2倍CPU核数（4个）线程运行，而不会以max_tn = 64/4＝16个线程运行。
在实际情况中，当然不能每个循环都象上面一样写几行代码来计算一遍，可以将其写成一个独立的功能函数如下：
const int g_ncore = omp_get_num_procs(); //获取执行核的数量
/** 计算循环迭代需要的线程数量
根据循环迭代次数和CPU核数及一个线程最少需要的循环迭代次数 来计算出需要的线程数量，计算出的最大线程数量不超过CPU核数
@param int n - 循环迭代次数
@param int min_n - 单个线程需要的最少迭代次数 @return int - 线程数量
*/
int dtn(int n, int min_n) {
int max_tn = n / min_n;
int tn = max_tn > g_ncore ? g_ncore : max_tn; //tn表示要设置的线程数量 if ( tn < 1 ) {
tn = 1; }
return tn; }
这样每次并行化循环时就可以直接使用函数dtn()来获取合适的线程数量，前面的代码可以简写成如下形式：
#pragma omp parallel for num_threads(dtn(n, MIN_ITERATOR_NUM)) for ( i = 0; i < n; i++ ) {
printf(\, omp_get_thread_num()); //Do some work here }
当然具体设置多少线程要视情况而定的，一般情况下线程数量刚好等于CPU核数可以取得比较好的性能，因为线程数等于CPU核数时，每个核执行一个任务，没有任务切换开销。
2、嵌套循环的并行化
在嵌套循环中，如果外层循环迭代次数较少时，如果将来CPU核数增加到一定程度时，创建的线程数将可能小于CPU核数。另外如果内层循环存在负载平衡的情况下，很难调度外层循环使之达到负载平衡。
下面以矩阵乘法作为例子来讲述如何将嵌套循环并行化，以满足上述扩展性和负载平衡需求。
一个串行的矩阵乘法的函数代码如下： /** 矩阵串行乘法函数
@param int *a - 指向要相乘的第个矩阵的指针 @param int row_a - 矩阵a的行数 @param int col_a - 矩阵a的列数
@param int *b - 指向要相乘的第个矩阵的指针 @param int row_b - 矩阵b的行数 @param int col_b - 矩阵b的列数
@param int *c - 计算结果的矩阵的指针
@param int c_size - 矩阵c的空间大小（总元素个数） @return void - 无
*/
void Matrix_Multiply(int *a, int row_a, int col_a, int *b, int row_b,int col_b, int *c, int c_size) {
if ( col_a != row_b || c_size < row_a * col_b ) {
return; }
int i, j, k;
//#pragma omp for private(i, j, k) for ( i = 0; i < row_a; i++ ) {
int row_i = i * col_a; int row_c = i * col_b;
for ( j = 0; j < col_b; j++ ) {
c[row_c + j] = 0;
for ( k = 0; k < row_b; k++ ) {
c[row_c + j] += a[row_i + k] * b[k * col_b + j]; } } } }
如果在外层循环前加上OpenMP的for语句时，它就变成了一个并行的矩阵乘法函数，但是这样简单地将其并行化显然无法满足前面所述的扩展性需求。
其实可以采用一个简单的方法将最外层循环和第2层循环合并成一个循环，下面便是采用合并循环后的并行实现。
void Parallel_Matrix_Multiply(int *a, int row_a, int col_a, int *b, int row_b,int col_b, int *c, int c_size ) {
if ( col_a != row_b ) {
return; }
int i, j, k; int index;
int border = row_a * col_b;
i = 0; j = 0;
#pragma omp parallel private(i,j,k) num_threads(dtn(border, 1)) for ( index = 0; index < border; index++ ) {
i = index / col_b; j = index % col_b;
int row_i = i * col_a; int row_c = i * col_b;
c[row_c+j] = 0;
for ( k = 0; k < row_b; k++ ) {
c[row_c + j] += a[row_i+k] * b[k*col_b+j]; } } }
从上面代码可以看出，合并后的循环边界border = row_a * col_b;即等于原来两个循环边界之积，然后在循环中计算出原来的外层循环和第2层循环的迭代变量i和j，采用除法和取余来求出i和j的值。
需要注意的是，上面求i和j的值必须要保证循环迭代的独立性，即不能有循环迭代间的依赖关系。不能将求i和j值的过程优化成如下的形式： if ( j == col_b ) {
j = 0; i++; }
// …… 此处代表实际的矩阵乘法代码
j++;
上面这种优化，省去了除法，效率高，但是只能在串行代码中使用，因为它存在循环迭代间的依赖关系，无法将其正确地并行化。