pthreads：使用多个线程计算连续的素数

Question

我试图让示例代码工作，以便多个线程将计算连续素数的总和（请注意，原作者的连续素数计算算法效率非常低）。到目前为止，运行单元测试显示输出不一致，即每次运行程序时它都会略有变化。我将在 C 中发布修改后的源代码，以及用于调试目的的输出。

来源：

/************************************************************************
 * Code listing from "Advanced Linux Programming," by CodeSourcery LLC  *
 * Copyright(C) 2001 by New Riders Publishing                           *
 * See COPYRIGHT for license information.                               *
 ***********************************************************************/

/*
 * Modified By : Dylan Gleason
 * Class       : CST 352 - Operating Systems
 * Date        : 10/18/2012
 */

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

#define DEBUG 0  /* Set to 1 to enable debug statements */

/* global variables to be accessed by each thread */
int current_sum = 2;
int primes_to_compute = 0;

/* create mutex for ensuring serial access to global data */
int thread_flag;
pthread_cond_t cond;
pthread_mutex_t lock;

/* print the thread info for debugging purposes */
void print_thread_info() 
{
   printf("Current thread ID        : %u\n",(unsigned int*)pthread_self());
   printf("Current sum of primes    : %d\n", current_sum);
   printf("Current prime to compute : %d\n\n", primes_to_compute);
}

/* initialize the mutex and return an integer value to determine if
   initialization failed or not */
int initialize_mutex()
{
   int success = 1;

   if(pthread_mutex_init(&lock, NULL) == 0 &&
      pthread_cond_init(&cond, NULL) == 0)
      success = 0;
   thread_flag = 0;

   return success;
}

/* set the value of the wait thread flag to the value which the client
   passes */
void set_thread_flag(int is_waiting)
{
   pthread_mutex_lock(&lock);   /* lock mutex */

   /* set the wait flag value, and then signal in case the prime
      function is blocked, waiting for flag to become set. However,
      prime function can't actually check flag until the mutex is
      unlocked */
   thread_flag = is_waiting;
   pthread_cond_signal(&cond);   
   pthread_mutex_unlock(&lock); /* unlock mutex */
}

void in_wait()
{
   while(!thread_flag)
      pthread_cond_wait(&cond, &lock);
}


/* Compute successive prime numbers(very inefficiently). Return the
   Nth prime number, where N is the value pointed to by *ARG. */
void* compute_prime(void* arg)
{   
   while(1)
   {
      pthread_mutex_lock(&lock);
      in_wait();
      pthread_mutex_unlock(&lock);

      int sum;
      int factor;
      int is_prime = 1;

      set_thread_flag(0);
      pthread_mutex_lock(&lock);
      sum = current_sum;

      if(DEBUG)
      {
         printf("First lock\n");
         print_thread_info();
      }

      pthread_mutex_unlock(&lock);
      set_thread_flag(1);          /* tell next thread to go! */

      /* wait until ready-flag is released from current thread */
      pthread_mutex_lock(&lock);
      in_wait();
      pthread_mutex_unlock(&lock);

      /* Test primality by successive division. */
      for(factor = 2; factor < sum; ++factor)
      {  
         if(sum % factor == 0)
         {
            is_prime = 0;
            break;
         }
      }

      /* Is this the prime number we're looking for? */
      if(is_prime)
      {
         int number;

         set_thread_flag(0);
         pthread_mutex_lock(&lock);

         /* only decrement primes_to_compute if is greater than zero! */
         if(primes_to_compute > 0)
         {
            --primes_to_compute;
         }       
         if(DEBUG)
         {
            printf("Second lock\n");
            print_thread_info();
         }

         number = primes_to_compute;
         pthread_mutex_unlock(&lock);
         set_thread_flag(1);

         pthread_mutex_lock(&lock);
         in_wait();
         pthread_mutex_unlock(&lock);

         if(number  == 0)
         {
            set_thread_flag(0);
            pthread_mutex_lock(&lock);
            void* sum =(void*) current_sum;

            if(DEBUG)
            {
               printf("Third lock\n");         
               print_thread_info();
            }

            pthread_mutex_unlock(&lock);
            set_thread_flag(1);
            return sum;
         }
      }

      set_thread_flag(0);
      pthread_mutex_lock(&lock);
      ++current_sum;

      if(DEBUG)
      {
         printf("Fourth lock\n");
         print_thread_info();
      }

      pthread_mutex_unlock(&lock);
      set_thread_flag(1);
   }

   return NULL;
}

int main(int argc, char* argv[])
{
   int prime;
   pthread_t tid[5];   

   /* Check command-line argument count */
   if(argc != 2)
   {
      printf("Error: wrong number of command-line arguments\n");
      printf("Usage: %s <integer>\n", argv[0]);
      exit(1);
   }

   /* Check to see if mutex initialized correctly */
   if(initialize_mutex() != 0)
   {
      printf("Mutex initialization failed.\n");
      exit(1);
   }

   primes_to_compute = atoi(argv[1]);
   printf("Successive primes to be computed: %d\n\n", primes_to_compute);

   /* Execute five different threads to calculate the prime summation */
   int t = 0;
   set_thread_flag(1);

   for(t; t < 5; ++t)
      pthread_create(&tid[t], NULL, &compute_prime, NULL);

   /* Wait for the prime number thread to complete, then get result. */
   t = 0;
   for(t; t < 5; ++t)
      pthread_join(tid[t],(void*) &prime);

   /* Print the largest prime it computed. */
   printf("The %dth prime number is %d.\n", atoi(argv[1]), prime);

   return 0;
}

单元测试（执行程序五次）：

Test successive primes up to 100:

Successive primes to be computed: 100
The 100th prime number is 547.

Successive primes to be computed: 100
The 100th prime number is 521.

Successive primes to be computed: 100
The 100th prime number is 523.

Successive primes to be computed: 100
The 100th prime number is 499.

Successive primes to be computed: 100
The 100th prime number is 541.

注意非线程版本的输出如果连续素数计算的数量是100，结果将始终是541。显然，我无法正确使用上述互斥锁 - 如果有人在这方面有更多经验，我将不胜感激！另外，请注意，我关心的不是实际素数算法的效率/正确性，而是确保线程正确执行并获得一致结果的算法。

Answer 1

好的，看看你的程序，我想我明白发生了什么。

你有一个竞争条件，而且非常糟糕。您所在的号码由current_sum 变量决定。您在每个循环开始时访问它，但在循环结束之前不要增加它。您需要在同一个互斥锁内同时设置然后递增它，否则两个不同的线程将能够提取相同的值，如果它们提取相同的素数，则该素数将被计算两次。

希望这会有所帮助。