为什么我的 pthreads 程序比顺序程序花费的时间更长

Question

我对多线程编程比较陌生。 我编写了一个程序，计算 0 - 10000 的平方并将它们保存到一个数组中。 顺序程序比并行程序运行得快得多。 在我的并行程序中，我将循环分成了 8 个线程（我的机器有 8 个内核）但是它慢得多吗？ 任何人都知道为什么会这样。 我添加了执行时间的屏幕截图。

/*Here is the normal program:*/

#define ARRAYSIZE 10000

int main(void) {

    int array[ARRAYSIZE];

    int i;

    for (i=0; i<ARRAYSIZE; i++)
    {
        array[i]=i*i;
    }

    return 0;
}

/*Here is the parallelized calculation. Used from http://ramcdougal.com/threads.html*/

#include <stdio.h>
#include <pthread.h>

#define ARRAYSIZE 10000
#define NUMTHREADS 8  /*Cause have 8 core on my machine*/

struct ThreadData {
    int start;
    int stop;
    int* array;
};

void* squarer (struct ThreadData* td);

/* puts i^2 into array positions i=start to stop-1 */
void* squarer (struct ThreadData* td)
{
    struct ThreadData* data = (struct ThreadData*) td;
    int start=data->start;
    int stop=data->stop;
    int* array=data->array;
    int i;
    for(i= start; i<stop; i++)
    {
        array[i]=i*i;
    }

    return NULL;
}

int main(void) {

int array[ARRAYSIZE];
pthread_t thread[NUMTHREADS];
struct ThreadData data[NUMTHREADS];
int i;

int tasksPerThread= (ARRAYSIZE + NUMTHREADS - 1)/ NUMTHREADS;

/* Divide work for threads, prepare parameters */
/* This means in my example I divide the loop into 8 regions: 0 ..1250,1250 .. 2500 etc., 2500 .. 3750 */

for(i=0; i<NUMTHREADS;i++)
{
    data[i].start=i*tasksPerThread;
    data[i].stop=(i+1)*tasksPerThread;
    data[i].array=array;

    data[NUMTHREADS-1].stop=ARRAYSIZE;
}

for(i=0; i<NUMTHREADS;i++)
{
    pthread_create(&thread[i], NULL, squarer, &data[i]);
}

for(i=0; i<NUMTHREADS;i++)
{
    pthread_join(thread[i], NULL);
}

return 0;
}

Answer 1

你想办一个游园会。 作为准备，您必须将 8 把椅子从房子里移到花园里。 你打电话给搬家公司，让他们派 8 个搬家工人。 他们从镇对面赶来，很快就完成了任务，每人一把椅子。 8 名搬运工驱车返回城镇的另一端。 当他们回来时，他们会打电话给你，告诉你任务已经完成。

问题：如果你自己移动8把椅子，整个过程会不会更快？

答：是的，实际任务（短距离移动 8 把椅子）太小了，不需要搬家公司。 来回运输所花费的时间远远超过任务本身所花费的时间。

上面的示例类似于您的代码所做的。

启动 8 个线程相当于从城镇的另一端开车到你家。

停止8个线程相当于返回。

与要解决的任务规模相比，浪费的时间太多了。

经验教训：只有在任务足够大时才使用多线程。

因此，对于您的测试，您应该增加ARRAYSIZE （很多）。 此外，您必须添加一些代码来防止编译器进行绕过数组赋值的优化。

尝试下面的代码（它是 OP 代码，有一些更改）。

单线程

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define ARRAYSIZE 1000000000
unsigned array[ARRAYSIZE];


int main(void) {

    unsigned i;

    for (i=0; i<ARRAYSIZE; i++)
    {
        array[i]=i*i;
    }

    srand(time(NULL));
    return array[rand() % ARRAYSIZE] > 10000;
}

我的结果：1.169 秒

多线程

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#define ARRAYSIZE 1000000000
unsigned array[ARRAYSIZE];
#define NUMTHREADS 8  /*Cause have 8 core on my machine*/

struct ThreadData {
    unsigned start;
    unsigned stop;
    unsigned* array;
};


/* puts i^2 into array positions i=start to stop-1 */
void* squarer (void* td)
{
    struct ThreadData* data = (struct ThreadData*) td;
    unsigned start=data->start;
    unsigned stop=data->stop;
    unsigned* array=data->array;
    unsigned i;
    for(i= start; i<stop; i++)
    {
        array[i]=i*i;
    }

    return NULL;
}

int main(void) {
  pthread_t thread[NUMTHREADS];
  struct ThreadData data[NUMTHREADS];
  int i;

  int tasksPerThread= (ARRAYSIZE + NUMTHREADS - 1)/ NUMTHREADS;

/* Divide work for threads, prepare parameters */
/* This means in my example I divide the loop into 8 regions: 0 ..1250,1250 .. 2500 etc., 2500 .. 3750 */

  for(i=0; i<NUMTHREADS;i++)
  {
    data[i].start=i*tasksPerThread;
    data[i].stop=(i+1)*tasksPerThread;
    data[i].array=array;

    data[NUMTHREADS-1].stop=ARRAYSIZE;
  }

  for(i=0; i<NUMTHREADS;i++)
  {
    pthread_create(&thread[i], NULL, squarer, &data[i]);
  }

  for(i=0; i<NUMTHREADS;i++)
  {
    pthread_join(thread[i], NULL);
  }

  srand(time(NULL));
  return array[rand() % ARRAYSIZE] > 10000;
}

我的结果：0.192 秒