Concurrent programming

Question

Hello, I’m having trouble finding the error in the code below. It is a problem where ideally, having 5 vacancies available, any one of the types of threads (server or trainee) can be sit freely, but when they fill the vacancies, the next vacancies are preferably of the servers, the interns only take the vacancies in case no server is waiting. With the code below, threads often loop and do not wait in pthread_cond_wait. How could I solve?

#include "stdio.h"
#include "unistd.h"
#include "stdlib.h"
#include "pthread.h"

#define VAGAS 4
#define SERVIDORES 5
#define ESTAGIARIOS 2

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t vez = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t lotou = PTHREAD_COND_INITIALIZER;                   
int contador = 0;
int contador_servidores = 0;
int contador_estagiarios = 0;

void mostra_que_quer_entrar(){
  pthread_mutex_lock(&mutex);
  contador++;
  pthread_mutex_unlock(&mutex);
}

void servidor_trabalha(int i){
  printf("Servidor %d: vou trabalhar em uma baia!\n", i);
  sleep(2); 
}

void servidor_vai_para_casa(int i){
  pthread_mutex_lock(&mutex);
  printf("Servidor %d: vou deixar a baia.\n", i);
  printf("servidor mandou sinal\n");
  pthread_cond_broadcast(&lotou);
  printf("servidor enviei sinal\n");
  contador--;
  pthread_mutex_unlock(&mutex);
  sleep(2);
}

void servidor_fica_esperando(int i){
  pthread_mutex_lock(&mutex);
  printf("Lotado\n");
  printf("Servidor %d: vou esperar >:|\n", i);
  contador_servidores++;
  contador--;
  while(contador== VAGAS){
    printf("servidor esperando sinal\n");
    pthread_cond_wait(&lotou, &mutex);
    printf("servidor recebeu sinal\n");
  }
  contador_servidores--;
  pthread_mutex_unlock(&mutex);
}

void estagiario_trabalha(int i){
  printf("Estagiario %d: vou trabalhar em uma baia!\n", i);
  sleep(2); 
}

void estagiario_vai_para_casa(int i){
  pthread_mutex_lock(&mutex);
  printf("Estagiario %d: vou deixar a baia.\n", i);
  printf("contador %d\n", contador);
  printf("estagiario  mandou sinal\n");
  pthread_cond_broadcast(&lotou);
  printf("estagiario mandou\n");
  contador--;
  pthread_mutex_unlock(&mutex);
  sleep(2);
}

void estagiario_fica_esperando(int i){
  pthread_mutex_lock(&mutex);
  printf("Lotado\n");
  printf("Estagiario %d: vou esperar :(\n", i);
  contador--;
  printf("contador %d\n", contador);
  while(contador == VAGAS){
    printf("estagiario esperando sinal\n");
    pthread_cond_wait(&lotou, &mutex);
    printf("estagiario recebeu sinal\n");
  }
  pthread_mutex_unlock(&mutex);
}

void* servidor(void * a){
  int i = *((int *) a);  
  while(1){

  mostra_que_quer_entrar();

    if(contador<=VAGAS){

      servidor_trabalha(i);

      servidor_vai_para_casa(i);

      break;

    }else{

      servidor_fica_esperando(i);

    }

  }
}

void* estagiario(void * a){
  int i = *((int *) a);  
  while(1){

  mostra_que_quer_entrar();
  printf("contador_servidores %d\n", contador_servidores);
    if(contador<=VAGAS && contador_servidores == 0){
      estagiario_trabalha(i);

      estagiario_vai_para_casa(i);

      break;
    }else{ 

      estagiario_fica_esperando(i);

    }
  }
}


int main(){

   pthread_t s[SERVIDORES];
   pthread_t e[ESTAGIARIOS];
   int i;
   int *id;
   for (i = 0; i < SERVIDORES ; i++) {
         id = (int *) malloc(sizeof(int));
         *id = i;
         pthread_create(&s[i], NULL, servidor, (void *) (id));
   }

   for (i = 0; i < ESTAGIARIOS ; i++) {
         id = (int *) malloc(sizeof(int));
         *id = i;
         pthread_create(&e[i], NULL, estagiario, (void *) (id));
   }

   for (i = 0; i < SERVIDORES ; i++) {
    pthread_join(s[i],NULL);
   }

   for (i = 0; i < ESTAGIARIOS ; i++) {
    pthread_join(e[i],NULL);
   }

   return 0;

}