c - 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 变量决定。您在每个循环开始时访问它，但在循环结束之前不要递增它。您需要在同一个互斥锁中同时设置并递增它，否则两个不同的线程将能够提取相同的值，如果它们提取相同的素数，那么该素数将被计算两次。

希望这对您有所帮助。