Question

a multi-threaded producer / consumer program without any locking or signaling. It therefore has synchronization problems. Add locks and signals so that it works correctly.
/* Homework 5.X */
/* Robin Ehrlich */

/* compile: gcc Homework5.c -lpthread */

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

struct class {
   struct class *next;
   int id;
   int grade;
};

#define SLEEP_TIME 1
#define MAX_PRODUCE 10

static struct class *classHead = NULL;
static struct class *classTail = NULL;
static pthread_mutex_t classMutex;
static pthread_cond_t classSignal;
static int producerComplete = 0;
static int randomSeed;

static void *consumerThread(void *arg)
{

   struct class *classCurrent;
   int sleepTime;

   printf("Consumer thread starting\n");

   while (1) {

       /* get next item */
      
       classCurrent = classHead;
       if ((classCurrent == NULL) && (producerComplete))
           break;
      
       classHead = classCurrent->next;

       /* do some work */
      
       printf("consume: id = %d, grade = %d\n", classCurrent->id,
           classCurrent->grade);
       sleepTime = (rand_r(&randomSeed) % SLEEP_TIME) + 1;
       sleep(sleepTime);
       free(classCurrent);
   }

   printf("Consumer thread completed\n");

   return (0);

}

static void *producerThread(void *arg)
{
  
   struct class *classCurrent;
   int i;
   int sleepTime;

   printf("Producer thread starting\n");

   for (i = 0; i < MAX_PRODUCE; i++) {

       /* do some work */
      
       printf("produce: id = %d, grade = %d\n", classCurrent->id,
               classCurrent->grade);
       sleepTime = (rand_r(&randomSeed) % SLEEP_TIME) + 1;
       sleep(sleepTime);

       /* give to consumer */

       classCurrent = malloc(sizeof(struct class));
       classCurrent->id = 462 + i;
       classCurrent->grade = 90 - i;
       classCurrent->next = NULL;
       if (classHead == NULL)
           classHead = classCurrent;
       else
           classTail->next = classCurrent;
       classTail = classCurrent;
   }

   producerComplete = 1;

   printf("Producer thread completed\n");

   return (0);

}

int main(int argc, char **argv)
{

   pthread_attr_t attr;
   struct class *classCurrent;
   pthread_t consumerTid;
   pthread_t producerTid;

   printf("Starting\n");

   randomSeed = (int) time(NULL);
   srand(randomSeed);

   pthread_mutex_init(&classMutex, NULL);
   pthread_cond_init(&classSignal, NULL);

   pthread_attr_init(&attr);
   pthread_create(&producerTid, &attr, producerThread, NULL);
   pthread_create(&consumerTid, &attr, consumerThread, NULL);

   /* wait for threads to complete */

   pthread_join(producerTid, NULL);
   pthread_join(consumerTid, NULL);

   printf("Completed\n");

   return (0);

}

Answer 1

Please find the following program that uses mutex and conditional variable to protect producer and consumer problem which has classList.

I have added comments as needed in the program

Program:

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

struct class {
struct class *next;
int id;
int grade;
};

#define SLEEP_TIME 1
#define MAX_PRODUCE 10

static struct class *classHead = NULL;
static struct class *classTail = NULL;
static pthread_mutex_t classMutex;
static pthread_cond_t classSignal;
static int producerComplete = 0;
static int randomSeed;

static void *consumerThread(void *arg)
{

struct class *classCurrent;
int sleepTime;

printf("Consumer thread starting\n");
//sleep(500);
while (1) {

//take the lock
pthread_mutex_lock(&classMutex);
/* get next item */

if (classHead == NULL && producerComplete ==0)
{
           //wait if the class is not populated and go further if producer filled the item
pthread_cond_wait(&classSignal,&classMutex);
}
classCurrent = classHead;
if ((classCurrent == NULL) && (producerComplete))
break;

classHead = classCurrent->next;

/* do some work */
   //after consuming release the lock and signal the producer
pthread_cond_signal(&classSignal);
pthread_mutex_unlock(&classMutex);

printf("consume: id = %d, grade = %d\n", classCurrent->id,
classCurrent->grade);
sleepTime = (rand_r(&randomSeed) % SLEEP_TIME) + 1;
sleep(sleepTime);
free(classCurrent);

}

printf("Consumer thread completed\n");

return (0);

}

static void *producerThread(void *arg)
{

struct class *classCurrent;
int i;
int sleepTime;

printf("Producer thread starting\n");

for (i = 0; i < MAX_PRODUCE; i++) {

/* do some work

printf("produce: id = %d, grade = %d\n", classCurrent->id,
classCurrent->grade); */
sleepTime = (rand_r(&randomSeed) % SLEEP_TIME) + 1;
sleep(sleepTime);

//take the lock here
pthread_mutex_lock(&classMutex);

/* give to consumer */
classCurrent = malloc(sizeof(struct class));
classCurrent->id = 462 + i;
classCurrent->grade = 90 - i;
classCurrent->next = NULL;
if (classHead == NULL)
classHead = classCurrent;
else
classTail->next = classCurrent;
classTail = classCurrent;
     
   //signal the consumer
pthread_cond_signal(&classSignal);
   //unlock the mutex to allow consumer to read
pthread_mutex_unlock(&classMutex);
}

producerComplete = 1;

printf("Producer thread completed\n");

return (0);

}

int main(int argc, char **argv)
{

pthread_attr_t attr;
struct class *classCurrent;
pthread_t consumerTid;
pthread_t producerTid;

printf("Starting\n");

randomSeed = (int) time(NULL);
srand(randomSeed);

pthread_mutex_init(&classMutex, NULL);
pthread_cond_init(&classSignal, NULL);

pthread_attr_init(&attr);
pthread_create(&producerTid, &attr, producerThread, NULL);
pthread_create(&consumerTid, &attr, consumerThread, NULL);

/* wait for threads to complete */

pthread_join(producerTid, NULL);
pthread_join(consumerTid, NULL);

printf("Completed\n");

return (0);

}