运行多个线程来实现数组答案

【问题标题】：Running multiple thread for implementing array运行多个线程来实现数组
【发布时间】：2021-12-26 14:15:21
【问题描述】：

#include <time.h>
#include <semaphore.h>
#include <pthread.h>
#include <unistd.h>

pthread_mutex_t pthread; sem_t th;

void *countOccurences(void* args){
    sem_wait(&th);
    sleep(2);
    pthread_mutex_lock(&pthread);
    time_t t;
    srand((unsigned) time(&t));
    int num[200000];
    for (int i = 0; i < 200000; i++){
            num[i] = (rand() % 1000) + 1;
    }
    for (int i = 1; i <= 1000; i++){
            int count = 0;
            for (int j = 0; j < 200000; j++){
                    if (i == num[j]){
                    count++;
            }
    }
    printf("%d occurs %d times \n", i, count);
    }

    pthread_mutex_unlock(&pthread);
    sem_post(&th); }

int main(){
    pthread_t thID[1];
    sem_init (&th, 0, 4);

    for (int i = 0; i <= 4; i++){
            pthread_create(&thID[i], NULL, countOccurences, NULL);
    }
    for (int i = 0; i <= 4; i++){
            pthread_join(thID[i],NULL);
    }
    pthread_mutex_destroy (&pthread);
    sem_destroy(&th);
    return 0; } ~

因为我想优化代码的执行时间，所以我被要求执行多个线程创建 200000 个随机数从 1 到 1000 的数组。但是，当我这样做时，输出是数组的 3 倍。但我希望只运行 1 个数组。我该如何解决这个问题？

输出： ...

986 occurs 208 times
987 occurs 229 times
988 occurs 207 times
989 occurs 203 times
990 occurs 217 times
991 occurs 178 times
992 occurs 178 times
993 occurs 177 times
994 occurs 170 times
995 occurs 196 times
996 occurs 212 times
997 occurs 178 times
998 occurs 219 times
999 occurs 228 times
1000 occurs 196 times
1 occurs 196 times
2 occurs 211 times
3 occurs 203 times
4 occurs 213 times
5 occurs 193 times
6 occurs 213 times
7 occurs 195 times
8 occurs 188 times
9 occurs 203 times
10 occurs 196 times
11 occurs 198 times
12 occurs 196 times
13 occurs 209 times

...

预期输出：

1 occurs 190 times
2 occurs 211 times
3 occurs 223 times
4 occurs 204 times
5 occurs 208 times
6 occurs 191 times
7 occurs 216 times
8 occurs 181 times
9 occurs 209 times
10 occurs 228 times
11 occurs 186 times
12 occurs 196 times
13 occurs 212 times
14 occurs 207 times
15 occurs 198 times
16 occurs 181 times
17 occurs 207 times
18 occurs 175 times
19 occurs 183 times
20 occurs 213 times
21 occurs 195 times
22 occurs 226 times

直到 1000：

989 occurs 200 times
990 occurs 185 times
991 occurs 206 times
992 occurs 188 times
993 occurs 215 times
994 occurs 213 times
995 occurs 210 times
996 occurs 207 times
997 occurs 211 times
998 occurs 187 times
999 occurs 191 times
1000 occurs 195 times

【问题讨论】：

你想用 4 个线程创建一个长度为 200000 的随机数数组吗？我不明白你为什么需要多线程，你不能简单地使用 for 循环来创建这样一个数组吗？具体要求是什么？
我使用多线程来加快执行速度，因为我被要求将原始方法与线程方法进行比较，以了解为什么线程可以帮助更快
你怎么看，3个线程同步访问一个数组？他们为什么会？您为 3 个线程调用相同的函数。此函数有 1 个数组（在每个线程中）并创建所有 200000 个数字（也在每个线程中），最后打印计数（再次在每个线程中）。如果您想要 1 个数组，请为所有线程提供一个数组。考虑一下哪个线程应该执行数组的哪个部分以及之后应该发生什么。
这也会导致未定义的行为：&thID[i] 这个数组只能保存 1 个值，但 i 可以上升到 4。顺便说一句：你确定你得到了 3 次输出吗？使用 5 个线程，您应该获得 5 倍相同的输出。（在上面的命令中，我错误地提到了 3 个线程，但它们是 5 个）
@Gerhardh 你能告诉我代码吗，因为这是我想要的，但我不知道该怎么做（当我的命令行只显示 3 时，5 次是准确的，所以这是我的错误） .谢谢

标签： c multithreading operating-system

【解决方案1】：

您需要为线程分配不同的任务。在您的版本中，每个线程都执行完整的任务，并且每个线程都执行相同的操作。这永远不会加快你的程序。

您需要使每个线程都可以访问一个数组。你需要告诉每个线程应该处理它的哪一部分。此外，您还可以通过在线程函数运行的整个过程中锁定信号量（和互斥体）来停用任何多线程。这与连续调用该函数 5 次基本相同。没有任何并行发生的事情。

固定（但未经测试）的版本可能如下所示：

#include <time.h>
#include <pthread.h>
#include <unistd.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

typedef struct {
  int             *data;
  size_t           num;
  volatile int   (*count)[1001];
} thread_data_t;

void *countOccurences(void* args) {
  thread_data_t *thread_data = (thread_data_t*)args;

  for (size_t i = 0; i < thread_data->num; i++) {
    thread_data->data[i] = (rand() % 1000) + 1;
  }

  for (size_t i = 0; i < 1000; i++) {
    int count = 0;
    for (size_t j = 0; j < thread_data->num; j++) {
      if (i == thread_data->data[j]) {
        count++;
      }
    }
    pthread_mutex_lock(&mutex);
    thread_data->count[i] += count;   
    pthread_mutex_unlock(&mutex);
  }
  return NULL;
}

int main(void) {
  int num[200000];
  volatile int count[1001] = {0};
  pthread_t thID[5];
  thread_data data[5] = {
    [0] = { &num[0],      40000, count},
    [1] = { &num[40000],  40000, count},
    [2] = { &num[80000],  40000, count},
    [3] = { &num[120000], 40000, count},
    [4] = { &num[160000], 40000, count},
  };

  srand((unsigned) time(NULL));

  for (size_t i = 0; i < 5; i++) {
    pthread_create(&thID[i], &data[i], countOccurences, NULL);
  }

  for (size_t i = 0; i < 5; i++) {
    pthread_join(thID[i],NULL);
  }
  pthread_mutex_destroy (&mutex);

  for (size_t i = 1; i <= 1000; i++) {
    printf("%d occurs %d times\n", i, count[i]);
  }

  return 0;
}

【讨论】：