SHARE
TWEET

Untitled

a guest May 22nd, 2019 73 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <pthread.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <stdlib.h>
  5. #include <unistd.h>
  6.  
  7. #define NUM_PROVAS 5
  8. #define MAX_GRADE 100
  9. #define NUM_THREADS 5
  10.  
  11. typedef struct {
  12.     int number;
  13.     int notaG1;
  14.     int notaG2;
  15.     int notaG3;
  16.     int notaFinal;
  17. } Prova;
  18.  
  19. Prova arrayProva[NUM_PROVAS];
  20. int numProvas;
  21.  
  22. int numPos;
  23. int numNeg;
  24.  
  25. int flag;
  26.  
  27. pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  28. pthread_mutex_t mutexInc = PTHREAD_MUTEX_INITIALIZER;
  29. pthread_cond_t condCreate = PTHREAD_COND_INITIALIZER;
  30. pthread_cond_t condCalculate = PTHREAD_COND_INITIALIZER;
  31. pthread_cond_t condPos = PTHREAD_COND_INITIALIZER;
  32. pthread_cond_t condNeg = PTHREAD_COND_INITIALIZER;
  33.  
  34. void *insertProvas(void *arg) {
  35.    
  36.     time_t t;
  37.     srand ((unsigned) time (&t));
  38.    
  39.     int i;
  40.     for (i = 0; i < NUM_PROVAS; i++) {
  41.        
  42.         Prova prova;
  43.         prova.number = rand() % 1000 + 1;
  44.         prova.notaG1 = rand() % MAX_GRADE + 1;
  45.         prova.notaG2 = rand() % MAX_GRADE + 1;
  46.         prova.notaG3 = rand() % MAX_GRADE + 1;
  47.        
  48.         arrayProva[i] = prova;
  49.        
  50.         pthread_mutex_lock(&mutex);
  51.         numProvas++;
  52.        
  53.         printf("Cria: %d\n", numProvas - 1);
  54.        
  55.         flag = 1;
  56.         pthread_cond_broadcast(&condCalculate);
  57.         printf("Calculate Start\n");
  58.        
  59.         pthread_mutex_unlock(&mutex);
  60.        
  61.         pthread_mutex_lock(&mutex);
  62.        
  63.         pthread_cond_wait(&condCreate, &mutex);
  64.        
  65.         pthread_mutex_unlock(&mutex);
  66.     }  
  67.    
  68.     pthread_mutex_lock(&mutex);
  69.        
  70.     flag = 1;
  71.     numProvas++;   
  72.     pthread_cond_broadcast(&condCalculate);
  73.    
  74.     pthread_mutex_unlock(&mutex);
  75.    
  76.     printf("Cria termina!\n");
  77.     pthread_exit(NULL);
  78.    
  79. }
  80.  
  81. void *calculateFinalNote(void *arg) {
  82.    
  83.     while (1) {
  84.        
  85.         pthread_mutex_lock(&mutex);
  86.        
  87.         printf("Calculate Wait\n");
  88.         while (flag == 0) {
  89.             pthread_cond_wait(&condCalculate, &mutex);
  90.         }
  91.        
  92.         int index = numProvas - 1;
  93.        
  94.         if (index == NUM_PROVAS) {
  95.             printf("Calculate finished!\n");
  96.            
  97.             pthread_cond_signal(&condCalculate);
  98.             pthread_mutex_unlock(&mutex);
  99.            
  100.             pthread_exit(NULL);
  101.         }
  102.         printf("Create Start\n");
  103.    
  104.         flag = 0;
  105.        
  106.         pthread_mutex_unlock(&mutex);
  107.    
  108.         printf("Calcula: %d\n", index);
  109.        
  110.         arrayProva[index].notaFinal = (arrayProva[index].notaG1 + arrayProva[index].notaG2 + arrayProva[index].notaG3) / 3;
  111.        
  112.         pthread_mutex_lock(&mutexInc);
  113.        
  114.         if (arrayProva[index].notaFinal < 50) {
  115.             printf("Incrementa prova negativa\n");
  116.             pthread_cond_signal(&condNeg);
  117.         } else {
  118.             printf("Incrementa prova positiva\n");
  119.             pthread_cond_signal(&condPos);
  120.         }
  121.        
  122.         pthread_mutex_unlock(&mutexInc);   
  123.    
  124.         pthread_mutex_lock(&mutex);
  125.        
  126.         pthread_cond_signal(&condCreate);
  127.        
  128.         pthread_mutex_unlock(&mutex);
  129.        
  130.     }
  131.    
  132.     pthread_exit(NULL);
  133.    
  134. }
  135.  
  136. void *incrementProvasPos(void *arg) {
  137.    
  138.     while (1) {
  139.         pthread_mutex_lock(&mutexInc);
  140.        
  141.         pthread_cond_wait(&condPos, &mutexInc);
  142.        
  143.         numPos++;
  144.         if (numPos + numNeg == NUM_PROVAS) {
  145.             pthread_exit(NULL);
  146.         }
  147.        
  148.         pthread_mutex_unlock(&mutexInc);
  149.     }  
  150.    
  151.     pthread_exit(NULL);
  152.    
  153. }
  154.  
  155. void *incrementProvasNeg(void *arg) {
  156.  
  157.     while (1) {
  158.         pthread_mutex_lock(&mutexInc);
  159.        
  160.         pthread_cond_wait(&condNeg, &mutexInc);
  161.        
  162.         numNeg++;
  163.         if (numPos + numNeg == NUM_PROVAS) {
  164.             pthread_exit(NULL);
  165.         }
  166.        
  167.         pthread_mutex_unlock(&mutexInc);
  168.     }  
  169.    
  170.     pthread_exit(NULL);
  171.    
  172. }
  173.  
  174. int main() {
  175.    
  176.     numProvas = 0;
  177.    
  178.     numPos = 0;
  179.     numNeg = 0;
  180.    
  181.     pthread_t threads[NUM_THREADS];
  182.    
  183.     int i;
  184.     for (i = 2; i < 4; i++) {
  185.         if (pthread_create(&threads[i], NULL, calculateFinalNote, NULL) != 0) {
  186.             printf("Erro no pthread_create()!\n");
  187.             exit(1);
  188.         }
  189.     }
  190.    
  191.     if (pthread_create(&threads[0], NULL, incrementProvasPos, NULL) != 0) {
  192.         printf("Erro no pthread_create()!\n");
  193.         exit(1);
  194.     }
  195.    
  196.     if (pthread_create(&threads[1], NULL, incrementProvasNeg, NULL) != 0) {
  197.         printf("Erro no pthread_create()!\n");
  198.         exit(1);
  199.     }
  200.    
  201.     if (pthread_create(&threads[4], NULL, insertProvas, NULL) != 0) {
  202.         printf("Erro no pthread_create()!\n");
  203.         exit(1);
  204.     }
  205.    
  206.     for (i = 2; i < NUM_THREADS; i++) {
  207.         if(pthread_join(threads[i], NULL) != 0){
  208.             perror("Erro a terminar thread...");
  209.             exit(1);
  210.         }
  211.     }
  212.    
  213.     for (i = 0; i < NUM_PROVAS; i++) {
  214.         printf("Aluno: %d  Nota G1: %d  Nota G2: %d  Nota G3: %d  Nota Final: %d\n", arrayProva[i].number, arrayProva[i].notaG1, arrayProva[i].notaG2, arrayProva[i].notaG3, arrayProva[i].notaFinal);
  215.     }
  216.    
  217.     printf("Provas positivas: %d\nProvas Negativas: %d\n", numPos, numNeg);
  218.    
  219.     return 0;
  220. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!
 
Top