/*
 * Thread 0 acorda thread 1
 */

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>


volatile int s = 0; 

pthread_cond_t cond;
pthread_mutex_t mutex;


int preciso_esperar() {
  return (s == 0);
}

void marca_thread_1_vai_dormir() {
  s = 1;
}

void *thread_1(void* v) {

  pthread_mutex_lock(&mutex);
  if (preciso_esperar()) {
    printf("Thread 1 vai esperar... \n");
    marca_thread_1_vai_dormir();
    pthread_cond_wait(&cond, &mutex);
    printf("Thread 1 acordou... \n");
  }
  pthread_mutex_unlock(&mutex);
  
  return NULL;
}

int devo_acordar_thread_1() {
  return (s == 1);
}

void marca_thread_0_ja_executou() {
  s = -1;
}

void *thread_0(void* v) {

  pthread_mutex_lock(&mutex);
  if (devo_acordar_thread_1()) {
    printf("Thread 0 vai acordar thread 1... \n");
    pthread_cond_signal(&cond);
  }
  marca_thread_0_ja_executou();
  pthread_mutex_unlock(&mutex);
  
  return NULL;
}

int main() {
  pthread_t thr[2];

  pthread_mutex_init(&mutex, NULL);
  pthread_cond_init(&cond, NULL);

  pthread_create(&thr[1], NULL, thread_1, NULL);
  pthread_create(&thr[0], NULL, thread_0, NULL);

  pthread_join(thr[1], NULL);
  pthread_join(thr[0], NULL);

  pthread_mutex_destroy(&mutex);
  pthread_cond_destroy(&cond);
  
  return 0;
}