:: Enseignements :: ESIPE :: E4INFO :: 2014-2015 :: Java Réseau I - Concurrence et E/S ::

TP noté de Concurrence

Le but de ce TP noté est d'écrire quelques classes permettant de vérifier que vous maitrisez les bases des mécanismes de protection de code exécuté de manière concurrente.

Vos sources Java produites pendant le TP devront être placées sous le répertoire EXAM de votre compte ($HOME) (qui est vierge dans l'environnement de TP noté); sinon, elles ne seront pas récupérées.

Tout document papier est proscrit. Vous pouvez consulter la javadoc à travers Eclipse (onglet Javadoc) ou en lançant la commande jdoc dans un shell. Les seuls documents électroniques autorisés sont les supports de cours à l'url http://igm.univ-mlv.fr/~forax/ens/java-avance/cours/pdf/.

Les exercices 1. et 2. sont complètement indépendants et peuvent être traités dans n'importe quel ordre.

Exercice 1 - Interruption

Dans une classe Interruption, on veut écrire un main qui démarre 10 thread. Chaque thread a un itentifiant de 0 à 9. Le thread d'identifiant id, commence par afficher le message "Thread id started". Puis il tire un entier entre 0 et 2 000 et attend ce nombre de millisecondes (vous utiliserez rand.nextInt() où rand est un objet de la classe java.util.Random). S'il se termine normalement, il affiche "Thread id finished". Si il est interrompu, il affiche "Thread id interrupted" et s'arrête.

Après avoir démarré ces 10 threads, le main attend une seconde et interrompt tous les threads. Une fois que tous les 10 threads ont fini leur exécution, il affiche "Program finished!".
Un affichage possible sera:
```
Thread 1 started
Thread 4 started
Thread 3 started
Thread 2 started
Thread 0 started
Thread 7 started
Thread 6 started
Thread 5 started
Thread 9 started
Thread 8 started
Thread 1 finished
Thread 2 finished
Thread 4 finished
Thread 0 finished
Thread 6 finished
Thread 5 finished
Thread 8 interrupted
Thread 7 interrupted
Thread 9 interrupted
Thread 3 interrupted
Program finished
```
On veut enrichir le programme précédent pour qu'après avoir affiché le message "Program finished!", il affiche le nombre de threads qui ont été interrompues (i.e., qui ont affiché le message "Thread id interrupted").

Pour cela créer une classe thread-safe Counter avec deux méthodes inc() et getValue() qui respectivement incrémente la valeur du compteur et renvoie sa valeur courante.
Un affichage possible sera:
```
Thread 1 started
Thread 4 started
Thread 3 started
Thread 2 started
Thread 0 started
Thread 7 started
Thread 6 started
Thread 5 started
Thread 9 started
Thread 8 started
Thread 1 finished
Thread 2 finished
Thread 4 finished
Thread 0 finished
Thread 6 finished
Thread 5 finished
Thread 8 interrupted
Thread 7 interrupted
Thread 9 interrupted
Thread 3 interrupted
Program finished
4 threads interrupted
```

Exercice 2 - Pizza pizza

Garfield (le chat de Jon) a décidé de manger autant de pizzas que possible, malheureusement il ne peux pas en manger plusieurs à la fois. Il a appelé (en utilisant la carte bleue de Jon) plusieurs services de livraison de pizzas, 7 pour être exact, pour être sûr de ne pas perdre un instant. Chaque livreur de pizza est capable d'apporter une nouvelle pizza en 50 milisecondes (rapide pizza !). Enfin, l'entrée de la maison de Jon est petite, et ne permet pas de stocker plus de 30 pizzas, dans ce cas les livreurs de pizza attendent sagement que Garfield fasse de la place en mangeant des pizzas.
Note: Garfield mange aussi les cartons de pizza car cela va plus vite.

En présupposant que la classe suivante existe déjà, écrire un main de test utilisant une thread pour garfield et 7 threads pour les 7 livreurs de pizzas qui livrent chacun une pizza toutes les 50 millisecondes. On suppose que Garfield utilise 5 millisecondes pour respirer entre chaque pizza.
```
      public class JonHouse {
        public void garfieldEatAPizza() ... { 
          ... 
        }
        public void pizzaGuyDeliverAPizza() ... { 
          ... 
        }
      }
    
```
Ecrire le code de la classe JonHouse sachant que l'on vous demande d'utiliser la classe java.util.concurrent.lock.ReentrantLock et non des blocks synchronized. Attention à gérer correctement les exceptions.