Mutex lock does not work as expected in C - c

Question

I try to implement a Hospital Simulation Project with threads but the mutex lock does not work as expected registration size should not be lower than zero if registration size is equal to zero then threads must wait for increment but if I increment the number of patients (they are also threads) registration size can be lower than 0. Why is that happening?
int REGISTRATION_SIZE = 10;
pthread_cond_t condRegister;
pthread_mutex_t mutex;
Patient:
struct Patient {
struct Disease disease;
pthread_t thread_id;
int thread_num;
int Hunger_Meter; // Initialized between 1 and 100 at creation.
int Restroom_Meter; // Initialized between 1 and 100 at creation.
};
Thread function:
void *thread_func(void *p){
struct Patient *patient = (struct Patient*)p;
registration();
return NULL;
}
Sleep method:
void sleepForMs(int ms){
usleep( 1000 * ms);
}
Thread Usage:
void registration(struct Patient *p){
int rnd_wait_time;
pthread_mutex_lock(&registration_mutex);
while(REGISTRATION_SIZE == 0){
rnd_wait_time = generate_rnd_numb(WAIT_TIME) + 1;
//printf("Patient[%d] waiting for an availabe desk.\n",p->thread_num);
sleepForMs(rnd_wait_time);
increase_meters(p);
checkForRestOrCafe(p);
pthread_cond_wait(&register_cond,&registration_mutex);
}
REGISTRATION_SIZE--;
printf(" Registration size: %d \n", REGISTRATION_SIZE);
pthread_mutex_unlock(&registration_mutex);
int register_time = generate_rnd_numb(REGISTRATION_TIME) + 1;
sleepForMs(register_time);
pthread_mutex_lock(&registration_mutex);
REGISTRATION_SIZE++;
pthread_mutex_unlock(&registration_mutex);
pthread_cond_signal(&register_cond);
}
Main:
int main()
{
pthread_mutex_init(&mutex, NULL);
pthread_cond_init(&condRegister, NULL);
srand(time(NULL));
int NUMB_OF_PATIENT = 3000;
struct Disease *diseases = malloc(sizeof(struct Disease));
diseases = create_diseases();
struct Patient patient[NUMB_OF_PATIENT];
create_patients(patient,NUMB_OF_PATIENT,diseases);
for (int i = 0; i < NUMB_OF_PATIENT; i++)
{
pthread_create(&(patient[i].thread_id), NULL, thread_func, (void *)(patient + i));
}
//wait for all threads
for (int i = 0; i < NUMB_OF_PATIENT; i++)
{
pthread_join(patient[i].thread_id, NULL);
}
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&condRegister);
return (0);
}
Divide Registration into functions:
void wait_for_available_resource(struct Patient *p, pthread_mutex_t mutex, pthread_cond_t cond, int resource){
int rnd_wait_time;
pthread_mutex_lock(&mutex);
while(resource == 0){
rnd_wait_time = generate_rnd_numb(WAIT_TIME) + 1;
sleepForMs(rnd_wait_time);
increase_meters(p);
checkForRestOrCafe(p);
pthread_cond_wait(&cond,&mutex);
}
resource--;
printf(" Resource Number: %d \n", resource);
pthread_mutex_unlock(&mutex);
}
void spend_process_time(int needed_time){
int elapsed_time = generate_rnd_numb(needed_time) + 1;
sleepForMs(elapsed_time);
}
void release_resource(pthread_mutex_t mutex, int resource_number, pthread_cond_t cond){
pthread_mutex_lock(&mutex);
printf("-----------\n");
printf("resource number:%d\n",resource_number);
resource_number++;
printf("resource number:%d\n",resource_number);
HOSPITAL_WALLET += REGISTRATION_COST;
printf("-----------\n");
pthread_mutex_unlock(&mutex);
pthread_cond_signal(&cond);
}
void registration(struct Patient *p){
wait_for_available_resource(p,registration_mutex,register_cond,REGISTRATION_SIZE);
spend_process_time(REGISTRATION_TIME);
release_resource(registration_mutex,REGISTRATION_SIZE,register_cond);
}