Barème : Q1.1: 3 points, Q1.2: 3 points, Q1.3: 6 points

1. Puisque plusieurs threads peuvent modifier le tableau simultanément, certaines modifications risquent d'être perdues. Par exemple, si acces_en_ecriture(t) comporte l'instruction t [2] ++; et que t[2] vaut 0, l'accès par 2 threads à cette instruction risque de ne pas incrémenter t[2] deux fois (ie. t[2] risque de valoir 1 au lieu de 2). Par ailleurs, les threads accèdant en lecture au tableau risquent de lire une valeur incohérente si un autre thread modifie le tableau au même moment.
2. Variable utilisée: sémaphore mutex (initialisé à 1)

   void f1() {
   

   P(mutex);
   acces_en_lecture(t);
   V(mutex);
   
   }

   void f2() {
   

   P(mutex);
   acces_en_ecriture(t);
   V(mutex);
   
   }

3. void fonction1 () {
   

   /* read_lock() */
   P(lock_lecteur); // protege la modification de nb_lecteurs
   nb_lecteurs++;
   // le premier lecteur s'assure qu'aucun ecrivain n'ecrit
   si(nb_lecteurs == 1)
   

   P(lock_ecrivains);
   

   fsi
   // else : on sait qu'il y a deja un lecteur, donc il n'y a pas d'ecrivain
   V(lock_lecteur);
   
   acces_en_lecture();
   
   /* read_unlock() */
   
   P(lock_lecteur); // protege la modification de nb_lecteurs
   nb_lecteurs--;
   si(nb_lecteurs == 0) // on est le dernier lecteur, on permet aux ecrivains d'ecrire
   

   V(lock_ecrivains);
   

   fsi
   V(lock_lecteurs);
   
   }
   
   void fonction2 () {
   
   /* write_lock() */
   P(lock_ecrivain);
   
   acces_en_ecriture();
   /* write_unlock() */
   
   V(lock_ecrivain);
   
   }