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

时间:2012-10-18 21:51:19

标签: c multithreading operating-system pthreads

我试图让示例代码工作,以便多个线程将计算连续素数的总和(请注意,原始作者的连续素数计算算法非常低效)。到目前为止,运行单元测试显示输出不一致,即每次运行程序时它都会略有变化。我将在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。很明显,我无法正确使用上面的互斥体 - 如果有人在这方面有更多的经验,我将非常感激!另外,请注意我并不关心实际素数算法的效率/正确性,而是确保线程以一致的结果正确执行的算法。

1 个答案:

答案 0 :(得分:1)

好的,看着你的节目,我想我知道发生了什么。

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

希望这有帮助。