e

#include <stdio.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <pthread.h>

#define NUM_THREADS 5
#define MAX_ELE_VEC 10000



int vec[MAX_ELE_VEC];

int count_ele_thread1=0;
int count_ele_thread2=0;
int count_ele_thread_3_4=0;
int count_ele_total=0;

pthread_mutex_t mut;
pthread_cond_t cond_thread3;
pthread_cond_t cond_thread4;
pthread_cond_t cond_thread5;


void* thread_func_1_2(void *arg){

    int *num_thread = (int*)arg;

    printf("Incrementacao do vec começou na thread %d\n",num_thread);
    do{
                pthread_mutex_lock(&mut);
                vec[count_ele_total]=rand()%99;
                count_ele_total++;
                if(num_thread==1){
                    count_ele_thread1++;
                    if(count_ele_thread1%50==0){
                        pthread_cond_signal(&cond_thread3);
                    }
                }else{
                    count_ele_thread2++;
                    if(count_ele_thread2%50==0){
                        pthread_cond_signal(&cond_thread4);
                    }
                }

                if(count_ele_total==5000){
                    pthread_cond_signal(&cond_thread5);
                }
                pthread_mutex_unlock(&mut);


    }while(count_ele_total<MAX_ELE_VEC);

    pthread_exit(NULL);

}


void* thread_func_3_4(void *arg){
        int *num_thread = (int*)arg;
        do{
            pthread_mutex_lock(&mut);
            if(num_thread==3){
                while(count_ele_total==count_ele_thread_3_4){
                    pthread_cond_wait(&cond_thread3,&mut);
                }
                while(count_ele_total>count_ele_thread_3_4){
                    printf("Thread 1 preencheu mais 50 posições\n");
                count_ele_thread_3_4=count_ele_thread_3_4+50;
                }
            }else{
                while(count_ele_total==count_ele_thread_3_4){
                    pthread_cond_wait(&cond_thread4,&mut);
                }
                while(count_ele_total>count_ele_thread_3_4){
                    printf("Thread 2 preencheu mais 50 posições\n");
                count_ele_thread_3_4=count_ele_thread_3_4+50;
                }
            }


            pthread_mutex_unlock(&mut);

        }while(count_ele_thread_3_4<MAX_ELE_VEC);

        pthread_exit((void*)NULL);  //nao retorna nada

}

void* thread_func5(void *arg){


            pthread_mutex_lock(&mut);

            pthread_cond_wait(&cond_thread5,&mut);

            printf("Thread 1 preencheu: %d posicoes\nThread2 preencheu: %d posicoes\nTotal: %d\n",count_ele_thread1,count_ele_thread2,count_ele_total);

            pthread_mutex_unlock(&mut);

        pthread_exit((void*)NULL);  //nao retorna nada

}






int main(){

    int i, ret;
    pthread_t threads[NUM_THREADS];


    //criacao do mutex para acesso exclusivo
    ret = pthread_mutex_init(&mut, NULL);   //NULL -> usa valores por omissao
    if (ret!=0){
        perror("ERRO NO MUTEX\n");
    }

    //CRIA VARIAVEIS CONDICAO
    ret = pthread_cond_init( &cond_thread3,NULL);
    if (ret!=0){
        perror("ERRO NA VARIAVEL CONDICAO\n");
    }

    ret = pthread_cond_init( &cond_thread4,NULL);
    if (ret!=0){
        perror("ERRO NA VARIAVEL CONDICAO\n");
    }

    ret = pthread_cond_init( &cond_thread5,NULL);
    if (ret!=0){
        perror("ERRO NA VARIAVEL CONDICAO\n");
    }




    //CRIACAO DAS THREADS

    for(i=0;i<NUM_THREADS;i++){
        int ret = pthread_create(&threads[i], NULL, posto,(void*)&(i+1));   //cast (void*) do indice +1
        if (ret!=0){
            perror("ERRO NA THREAD\n");
        }
    }




    /***************************THREADS A FUNCIONAR***********************/

    printf("Todas as threads foram criadas\n");


    //a thread MAIN vai esperar por todas as threads
    for(i=0;i<NUM_THREADS;i++){
        pthread_join(threads[i], NULL);
    }

    pthread_mutex_destroy(&mut);
    pthread_cond_destroy(&cond_thread3);
    pthread_cond_destroy(&cond_thread4);
    pthread_cond_destroy(&cond_thread5);
    printf("Todas as threads terminaram\n");

    return 0;
}