Semaphores and Deadlocks in C

Question

I'm trying to code the producer/consumer problem using semaphores. I have 3, 1 acting as a mutex, and another 2 for the buffer which the producers and consumers can add/remove from. When adding/removing from the buffer I use the binary semaphore to lock/unlock it so that the global variables aren't subject to any race conditions. The produce semaphore represents how many spots are available in the buffer (how many things can be put into the buffer) while the consumer semaphore represents how many things can be removed from the buffer. I think my logic is wrong cause I always reach a deadlock. Also when I removed the produce and consume semaphores just to test whether or not the program does what its supposed to do, I still get race conditions even though the binary semaphore should be blocking that. What am I doing wrong?

enter code here
#include <stdio.h>  
#include <sys/types.h>  
#include <unistd.h> 
#include <stdlib.h>     
#include <sys/wait.h>   
#include <pthread.h>
#include </usr/include/semaphore.h>

#define MAXITEMS 100    
#define PRODUCER_NO 5   
#define NUM_PRODUCED 5 

void *producer_function (void);
void *consumer_function (void);
void add_buffer (long i);
long get_buffer ();


long sum_value = 0; 
long finished_producers;
long buffer[MAXITEMS];  
int size = 0;       
int front, rear = 0;    

pthread_t producerThread[5];
pthread_t consumerThread;
sem_t mutex, produce, consume;

int main(void)
{
    int i = 0;
    srand (time(NULL));
    sem_init (&mutex, 0, 1);
    sem_init (&produce, 0, 100);
    sem_init (&consume, 0, 0);
    for (i = 0; i < 5; i++)
    {
        pthread_create (&producerThread[i], NULL, (void *) producer_function, NULL);
    }
    pthread_create (&consumerThread, NULL, (void *) consumer_function, NULL);
    for (i = 0; i < 5; i++)
    {
        pthread_join (producerThread[i], NULL);
    }
    pthread_join (consumerThread, NULL);
    return(0);
}

void *producer_function(void)
{   
    long counter = 0;
    long producer_sum = 0L;
    while (counter < NUM_PRODUCED) 
    {
        sem_wait (&mutex);
        sem_wait (&produce);
        long rndNum = rand() % 10; 
        producer_sum += rndNum;
        add_buffer (rndNum);
        sem_post (&consume);
        counter++;
        if (counter == NUM_PRODUCED)
        {
            finished_producers++;
        }
        sem_post (&mutex);
        usleep(1000);
    }

    printf("--+---+----+----------+---------+---+--+---+------+----\n");
    printf("The sum of produced items for this producer at the end is: %ld \n", producer_sum);
    printf("--+---+----+----------+---------+---+--+---+------+----\n");
    return(0);
}

void *consumer_function (void)
{   
    while (1) 
    {
        sem_wait (&mutex);
        sem_wait (&consume);
        long readnum = get_buffer();
        sem_post (&produce);
        sum_value += readnum;
        sem_post (&mutex);
        //printf ("%ld\n", sum_value);
        if ((finished_producers == PRODUCER_NO) && (size == 0))
        {
            printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
            printf("The sum of the all produced items at the end is: %ld \n", sum_value);
            printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
            break;
        }
    }
}

void add_buffer(long i){
    buffer[rear] = i;
    rear = (rear+1) % MAXITEMS;
    size++;
}

long get_buffer(){
    long v;
    v = buffer[front];
    front = (front+1) % MAXITEMS;
    size--;
    return v;
}

Answer 1

user2929779,

I think its essential to not have the mutex locked, when waiting for a consume notification in the consumer, or vice versa a produce notification in the producer. Imagine you're getting blocked because of waiting for a consume notification, and no producer was able to publish such a notification then your consumer keeps the mutex locked and no producer ever gets the chance to produce a new item...

So the order is important here: 1.) First wait for notification from remote side 2.) lock mutex 3.) modify global data 4.) release mutex 5.) notify remote side

Try this instead:

void *producer_function(void)
{   
    long counter = 0;
    long producer_sum = 0L;
    while (counter < NUM_PRODUCED) 
    {

        sem_wait (&produce);
        sem_wait (&mutex);
        long rndNum = rand() % 10;
        producer_sum += rndNum;
        add_buffer (rndNum);
        counter++;
        if (counter == NUM_PRODUCED)
        {
            finished_producers++;
        }
        sem_post (&mutex);      
        sem_post (&consume);
        usleep(1000);
    }

    printf("--+---+----+----------+---------+---+--+---+------+----\n");
    printf("The sum of produced items for this producer at the end is: %ld \n", producer_sum);
    printf("--+---+----+----------+---------+---+--+---+------+----\n");
    return(0);
}

void *consumer_function (void)
{   
    while (1) 
    {

        sem_wait (&consume);
        sem_wait (&mutex);
        long readnum = get_buffer();
        sum_value += readnum;
        if ((finished_producers == PRODUCER_NO) && (size == 0))
        {
            printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
            printf("The sum of the all produced items at the end is: %ld \n", sum_value);
            printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
            break;
        }
        sem_post (&mutex);
        sem_post (&produce);

    //printf ("%ld\n", sum_value);
    }
    return(0);
}

P.S. For now ignoring return values of system calls just to show example implementation...

P.S.S. See also pseudo code on wiki http://en.wikipedia.org/wiki/Producer%E2%80%93consumer_problem#Using_semaphores ...