Producer Consumer Never terminating - c

Question

I am using multi thread and I have made a program where producer creates values and insert into buffer and consumer consumes it.
However consumer never terminates. I would like to terminate the consumer process when there is nothing left to consume.
Is there any way to change the code?
This is the main code
#include<pthread.h>
#include <stdio.h>
/* Producer/consumer program illustrating conditional variables */
/* Size of shared buffer */
#define BUF_SIZE 3
int buffer[BUF_SIZE]; /* shared buffer */
int add=0; /* place to add next element */
int rem=0; /* place to remove next element */
int num=0; /* number elements in buffer */
pthread_mutex_t m=PTHREAD_MUTEX_INITIALIZER; /* mutex lock for buffer */
pthread_cond_t c_cons=PTHREAD_COND_INITIALIZER; /* consumer waits on this cond var */
pthread_cond_t c_prod=PTHREAD_COND_INITIALIZER; /* producer waits on this cond var */
void *producer(void *param);
void *consumer(void *param);
main (int argc, char *argv[])
{
pthread_t tid1, tid2; /* thread identifiers */
int i;
/* create the threads; may be any number, in general */
if (pthread_create(&tid1,NULL,producer,NULL) != 0) {
fprintf (stderr, "Unable to create producer thread\n");
exit (1);
}
if (pthread_create(&tid2,NULL,consumer,NULL) != 0) {
fprintf (stderr, "Unable to create consumer thread\n");
exit (1);
}
/* wait for created thread to exit */
pthread_join(tid1,NULL);
pthread_join(tid2,NULL);
printf ("Parent quiting\n");
}
This is the producer part
/* Produce value(s) */
void *producer(void *param)
{
int i;
for (i=1; i<=20; i++) {
/* Insert into buffer */
pthread_mutex_lock (&m);
if (num > BUF_SIZE) exit(1); /* overflow */
while (num == BUF_SIZE) /* block if buffer is full */
pthread_cond_wait (&c_prod, &m);
/* if executing here, buffer not full so add element */
buffer[add] = i;
add = (add+1) % BUF_SIZE;
num++;
pthread_mutex_unlock (&m);
pthread_cond_signal (&c_cons);
printf ("producer: inserted %d\n", i); fflush (stdout);
}
printf ("producer quiting\n"); fflush (stdout);
}
This is the consumer part
/* Consume value(s); Note the consumer never terminates */
void *consumer(void *param)
{
int i;
while (1) {
pthread_mutex_lock (&m);
if (num < 0) exit(1); /* underflow */
while (num == 0) /* block if buffer empty */
pthread_cond_wait (&c_cons, &m);
/* if executing here, buffer not empty so remove element */
i = buffer[rem];
rem = (rem+1) % BUF_SIZE;
num--;
pthread_mutex_unlock (&m);
pthread_cond_signal (&c_prod);
printf ("Consume value %d\n", i); fflush(stdout);
}
}

Answer 1

The usual way to do this is for the producer to put something in the buffer that tells the consumer it's quitting. Since your numbers go from 1 to 20, you could choose that a 0 or a -1 means the end. When the producer ends it puts -1 in the buffer and when the consumer sees a -1 in the buffer it also ends.