l-thread.c

An exercise with thread of C. If you want to explore this programming language you must know the th

#include "in.h"
#define TRENI_MAX 500
#define MAX_TIME_TRAIN_PASS 3
#define rand_train(min,max) (int)(rand()%(max-min+1) + min)

pthread_mutex_t binario; /*L'astrazione virtuale del binario in mutex*/

QUEUE a={NULL,NULL};     /*La coda, astrazione della stazione*/

/********************************************************************/
/*Funzioni per la gestione della coda*/
int isempty(QUEUE q) { return (q.front == NULL); }

DATA vfront(QUEUE q) { return(q.front->d); }

void dequeue(QUEUE *q,DATA *x)
{
 LINK temp=q->front;

 if(!isempty(*q))
  {
  *x=temp->d;
  q->front=temp->next;
  free(temp);
  } else
 printf("Empty queue\n");
}


void enqueue(QUEUE *q, DATA x)
{

 LINK temp;
 
 temp=malloc(sizeof(ELEMENT));
 temp->d=x;
 temp->next=NULL;
 if(isempty(*q))
 q->front=q->rear=temp;
 else {
  q->rear->next=temp;
  q->rear=temp;
  }
}

/*******************************************************************/
/*Gestione dell'astrazione "stazione" implementata con i thread*/

void *gestione_dei_binari(void *i)
{
 printf ("ARRIVA :%d\n",(int)(i));  /* Il treno con id i arriva in stazione*/
 int r=(int)(i);

 enqueue(&a,r);                     /* Viene messo in coda */
 while(1)
  {                          /* Ciclo infinitivamente la richiesta di passaggio*/
  if(pthread_mutex_lock(&binario)==-1) /* se il binario è occupato aspettoil tempo massimo di passaggio */
   {
//  printf ("Aspetto i binari \n");
   sleep(MAX_TIME_TRAIN_PASS);        /* Aspetto il tempo massimo di passaggio del treno sui binari*/
   }
  printf ("Do il binario a %d\n",(int)(vfront(a))); /*Quindi i binari sono liberi e li do al primo della coda che è variaile universale*/
  sleep(rand_train(0,MAX_TIME_TRAIN_PASS));       /*Quindi aspetto un tempo random tra 0 e il tempo massimo di passaggio che il treno passi*/
  printf ("Il treno %d lascia i binari\n",(int)(vfront(a)));  
  dequeue(&a,&r);                                   /*Il treno si toglie in cima della coda*/
  pthread_mutex_unlock(&binario);                   /*E lascia i binari*/
  sleep(rand_train(0,5));				/*Dato che si vuole ciclare sullo stesso insieme di treni senza */
				/*Creare altri thread Si aspetta un tempo 0<tempo<5 random che il treno ritorni alla stazione*/
  enqueue(&a,r); 				/*uindi lo rimetto in coda*/               
  printf ("RIARRIVA %d\n",r);
 }
}


int main(int argc, char *argv[])
{
   int i,trains;
   pthread_attr_t attr;
   
   if (argc<2) {
   printf ("[*] L-thread : Usage ./l-thread num_trains [*]\n");
   exit(0);
   }
   if ((trains=atoi(argv[1]))<0)
   {
   printf ("[*] Trains must be >>0 [*]\n");
   exit(0);
   }

   struct  {
   int id;
   pthread_t treno; 
   } treni[trains];
 
  /*setto gli attributi per il thread che gestisce la stazione*/
   pthread_attr_init(&attr);
   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
   /*Inizializzio il mutex*/
   pthread_mutex_init(&binario, NULL);
    for(i=1;i<trains+1;i++){
    treni[i].id=i;  
if (pthread_create(&treni[i].treno,NULL,gestione_dei_binari,(void *)(treni[i].id))) /*Gestisco i treni che vogliono i binari*/
     {
   perror("pthread_thread_create");
   exit(-1);
     }}
pthread_exit((void *) 0); 
}