工作线程和控制器线程同步

Question

我无法让我的工作线程和促进线程正确同步。我要解决的问题是使用最多 10 个线程找到最大的素数 10 文件。 1 个线程是单线程的，超过这个数的线程是多线程的。

问题在于工人向引导者发出信号，表明它找到了一个新的素数。如果数字无关紧要，引导者可以忽略它，或者如果它很重要，则通知更新所有线程my_latest_lgprime。我一直卡在我的大脑和代码中。

任务必须通过协调者和同步来完成。

这是我目前所拥有的：

工人：

void* worker(void* args){
     w_pack* package = (w_pack*) args;
     int i, num;
     char text_num[30];
     *(package->fac_prime) = 0;
     for(i = 0; i<package->file_count; i++){
          int count = 1000000; //integers per file
          FILE* f = package->assigned_files[i];
          while(count != 0){
               fscanf(f, "%s", text_num);
               num = atoi(text_num);
               pthread_mutex_lock(&lock2);
               while(update_ready != 0){
                    pthread_cond_wait(&waiter, &lock2);
                    package->my_latest_lgprime = largest_prime;//largest_prime is global
                    update_ready = 0;
               }
               pthread_mutex_unlock(&lock2);
               if(num > (package->my_latest_lgprime+100)){
                    if(isPrime(num)==1){
                         *(package->fac_prime) = num;
                         package->my_latest_lgprime = num;
                         pthread_mutex_lock(&lock);
                         update_check = 1;
                         pthread_mutex_unlock(&lock);
                         pthread_cond_signal(&updater);  
                    }

               }
               count--;
          }
     }

     done++;
     return (void*)package;
}`

主持人：

void* facilitator(void* args){
     int i, temp_large;
     f_pack* package = (f_pack*) args;

     while(done != package->threads){
          pthread_mutex_lock(&lock);
          while(update_check == 0)
               pthread_cond_wait(&updater, &lock);
          temp_large = isLargest(package->threads_largest, package->threads);
          if(temp_large > largest_prime){
               pthread_mutex_lock(&lock2);
               update_ready = 1;
               largest_prime = temp_large;
               pthread_mutex_unlock(&lock2);
               pthread_cond_broadcast(&waiter);
               printf("New large prime: %d\n", largest_prime);
          }
          update_check = 0;
          pthread_mutex_unlock(&lock);
     }
}

这是工作包

typedef struct worker_package{
     int my_latest_lgprime;
     int file_count;
     int* fac_prime;
     FILE* assigned_files[5];
} w_pack;

有没有更简单的方法使用信号量来做到这一点？

Answer 1

我无法确定确实存在问题，但仅通过简要阅读代码，似乎done 变量在线程之间共享，但它在没有同步的情况下被访问和修改。

无论如何，我可以提出一些想法来改进您的解决方案。

1. 在启动时将文件列表分配给每个线程。这不是最有效的方法，因为处理每个文件可能需要更多或更少的时间。在我看来，更好的方法是拥有一个文件列表，然后每个线程选择列表中的下一个文件。

2. 你真的需要一个引导者任务吗？在我看来，每个线程都可以跟踪自己的最大素数，并且每次找到新的最大值时，它都可以检查全局最大值并在必要时对其进行更新。您也可以保留一个最大值（没有每个线程的最大值），但这需要您在每次需要比较时锁定。

这是我将如何编写工作线程的伪代码：

while (true) {
    lock(file_list_mutex)
    if file list is empty {
        break // we are done!
    }
    file = get_next_file_in_list
    unlock(file_list_mutex)

    max = 0
    foreach number in file {
        if number is prime and number > max {
            lock(max_number_mutex)
            if (number > max_global_number) {
                max_global_number = number
            }
            max = max_global_number
            unlock(max_number_mutex)
        }
    }
}

在启动工作线程之前，您需要初始化max_global_number = 0。

上述解决方案的好处是它不会像您的情况那样滥用锁，因此可以最大限度地减少线程争用。