the following I am not confused over the "idea" of this producer/consumer problem, but im still confused about threads and semaphores and stuff. this particular program has 4 threads that read or consume from a shared variable. It has 1 thread that writes or produces to that shared variable. All the thread loops need to loop indefinitly which im sure i havent done. and on each loop iteration it requirs 1 second on computation without access to the shared variable.

And the data output i have in main needs to print report every second. My code has no errors, but it is exiting a 1. i definitely need some help! i tried my best to comment the code as to what is going on.

The code needs to be in C!
Code:
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <semaphore.h>

#define BUFF_SIZE   100	/* total number of slots */
#define NP          1		/* total number of producers */
#define NC          4		/* total number of consumers */
#define NITERS      4		/* number of items produced/consumed */

typedef struct {
    int buf[BUFF_SIZE];   /* shared var */
    int in;         	  /* buf[in%BUFF_SIZE] is the first empty slot */
    int out;        	  /* buf[out%BUFF_SIZE] is the first full slot */
    sem_t full;     	  /* keep track of the number of full spots */
    sem_t empty;    	  /* keep track of the number of empty spots */
    sem_t mutex;    	  /* enforce mutual exclusion to shared data */
} sbuf_t;

sbuf_t shared;

/* function prototypes */
void *Producer(void *arg);
void *Consumer(void *arg);

/* increments and decrements */
int produced, consumed;

int main()
{
   /* producer/consumer threads */
    pthread_t idP, idC;
    
    /* loop control */
    int index;
    
    /* temp variables to comp the consumes and produces per hour */
    int temp1, temp2;

    /* keeps track of seconds */
    int j = 1;

    /* creates semaphores */
    sem_init(&shared.full, 0, 0);
    sem_init(&shared.empty, 0, BUFF_SIZE);
    sem_inti(&shared.mutex, 0, 1);
    

    /* creates producer thread */
    for (index = 0; index < NP; index++)
    {  
       /* Create 1 producer */
       pthread_create(&idP, NULL, Producer, (void*)index);
    }

    /* creates 4 consumer threads */
    for (index = 0; index < NC; index++)
    {
       pthread_create(&idC, NULL, Consumer, (void*)index);
    }
    

    while(1)
    {
       sleep(1);
       sem_wait(&shared.mutex);
       temp1 = (consumed * 3600) / j;
       temp2 = (produced * 3600) / j;
       printf("Statistics after %d seconds: ", j);
       sem_post(&shared.mutex);
       printf("So many consumed per hour: %d\n", temp1);
       printf("So many produced per hour: %d\n", temp2);
       printf("Ratio of consumed/produced per hour: %d", temp1 / temp2);
       j++;
    }
       

    sem_destroy(&shared.mutex); // destroy semaphore
    pthread_exit(NULL);
}
void *Producer(void *arg)
{
    int data, index;

    index = (int)arg;

    printf("Thread %d in line to  produce\n", index);

    for (produced=0; produced < NITERS; produced++) {

        /* Produce item */
        data = produced;
        printf("[P%d] Producing %d ...\n", index, data); fflush(stdout);

       data=produce_item(shared.buf);

        /* If there are no empty slots, wait */
        sem_wait(&shared.empty);
        /* If another thread uses the buffer, wait */
        sem_wait(&shared.mutex);
        /* put new item in buffer */
        shared.buf[shared.in] = data;
        shared.in = (shared.in+1)%BUFF_SIZE;
        /* leave the critical region */
        sem_post(&shared.mutex);
        /* Increment the number of full slots */
        sem_post(&shared.full);

        /* Interleave  producer and consumer execution */
        if (produced % 2 == 1) sleep(1);
    }
    return NULL;
}

void *Consumer(void *arg)
{
   int data, index;

    index = (int)arg;

    int consumed;
    printf("[C%d] Consuming %d ...\n", index, data); fflush(stdout);

    for (consumed=0; consumed < NITERS; consumed++) {

        data = consumed;

        /* If there are no full slots, wait */
        sem_wait(&shared.full);
        /* If another thread uses the buffer, wait */
        sem_wait(&shared.mutex);
        shared.buf[shared.out] = data;
        shared.out = (shared.out+1)%BUFF_SIZE;
        /* Release the buffer */
        sem_post(&shared.mutex);
        /* Increment the number of empty slots */
        sem_post(&shared.empty);

        /* Interleave  producer and consumer execution */
        if (consumed % 2 == 1) sleep(1);
    }
    return NULL;
}