diff --git a/rapport.txt b/rapport.txt index 0686f26..19fe5d7 100644 --- a/rapport.txt +++ b/rapport.txt @@ -1,9 +1,9 @@ Nous avons la Class Au_Wok qui contient le main(), on y initialise les clients ainsi que le restaurant, puis on start tous les clients. -Le constructeur Restaurant initialise le Buffet : un tableau de 4 Compartiment -(poisson, viande, légume et nouille), le Cusinier, le stand de cuisson, -l'Employe_du_buffet. Puis il star en suite start l'employer du buffet. +Le constructeur Restaurant initialise le Buffet, un tableau de 4 Compartiment +(poisson, viande, légume et nouille), le stand de cuisson, l'Employe_du_buffet +et le Cuisinier. Il star en suite start ces deux derniers. Le run de Client va suivre ces étapes : (1) Entrer dans le restaurant en vérifiant bien que le restaurant est libre @@ -11,20 +11,22 @@ Le run de Client va suivre ces étapes : le verrou du compartiment est libre avant de lui-même le verrouiller, après c'être servi il déverrouille fait un notifyAll pour réveiller les clients ou l'employer du buffet qui pourrait attendre. - (3) Cuire au stand, on utilise un sémaphore. + (3) Cuire au stand, en se mettant dans la queue (il notifyAll le stand pour + réveiller le cuisinier), quand son plat est cuit le cuisinier le sort de la + queue (le stand fait un notifyAll pour réveiller le client) (4) Manger (5) Sort, en faisant un notifyAll sur le restaurant pour prévenir tout autre thread client attendant pour entrer +Le run du cuisinier, fait une boucle pour vérifier si un client est présent en +tête de la queue du stand de cuisson. Si oui, alors il fait cuire son plat. +Une fois fini, il sort le client le la queue et fait faire un notifyAll au stand +pour prévenir le client que son plat est fini. + L'employer du buffet fait le tour de chaque compartiment du buffet, s'il y a un un buffet à moins de 100g alors il vérifie qu'il est libre (se met en wait sinon) et le remplit. - Difficulté : -Nous n'avons pas vraiment rencontré de difficulté, on a juste eu parfois quelque -oublie (notifyAll manquant par exemple). -On avait aussi commencé dans Stand_de_cuisson par faire une Queue, on a ensuite -remplacé par un sémaphore, qui est au final beaucoup plus simple, mais le verrou -n'est plus équitable, ce n'est plus le Client qui attend depuis le plus long temps -qui est prioritaire. \ No newline at end of file +Nous avons pas vraiment rencontré de difficulté, on a juste eu parfois quelque +oublie (notifyAll manquant par exemple) \ No newline at end of file diff --git a/src/Client.java b/src/Client.java index 7d7922f..fb4f952 100644 --- a/src/Client.java +++ b/src/Client.java @@ -82,9 +82,16 @@ public class Client extends Thread { } public void cuir_au_stand(Stand_de_cuisson stand){ + stand.ajouter_client(this); System.out.println(this.getNameClient() + " : attend pour faire cuir son plat"); synchronized(stand){ - stand.faire_cuire_plat(this); + try{ + while(stand.containsClient(this)){ + stand.wait(); + } + }catch (InterruptedException e){ + e.printStackTrace(); + } } System.out.println(this.getNameClient() + " : le plat est cuit"); diff --git a/src/Cuisinier.java b/src/Cuisinier.java index 1b8ff7f..a1f5b71 100644 --- a/src/Cuisinier.java +++ b/src/Cuisinier.java @@ -1,12 +1,35 @@ import java.util.Random; public class Cuisinier extends Thread { + private Stand_de_cuisson stand; - public Cuisinier(){ - + public Cuisinier(Stand_de_cuisson stand_de_cuisson){ + this.stand= stand_de_cuisson; this.setDaemon(true); } + public void run(){ + while(Thread.currentThread().isDaemon()){ + attendreClient(); + } + } + + private void attendreClient(){ + Client client = stand.getClient(); + synchronized(stand){ + try{ + while(client==null){ + stand.wait(); + client= stand.getClient(); + } + } + catch(InterruptedException e){ + e.printStackTrace(); + } + } + faire_cuire(client); + } + public void faire_cuire(Client client){ System.out.println("# Cuisinier : fait cuire le plat de " + client.getNameClient()) ; try{ @@ -16,5 +39,7 @@ public class Cuisinier extends Thread { e.printStackTrace(); } System.out.println("# Cuisinier : a fini de cuire le plat de " + client.getNameClient()) ; + stand.nextClient(); + stand.finir_cuit(); } } diff --git a/src/Restaurant.java b/src/Restaurant.java index add0e1f..5f7c8b8 100644 --- a/src/Restaurant.java +++ b/src/Restaurant.java @@ -7,8 +7,27 @@ public class Restaurant { public Employe_du_buffet employeB; public Stand_de_cuisson stand_de_cuisson; public Cuisinier cuisinier; + /* + private Client[] clients= new Client[MAX_CLIENTS+5]; + Restaurant(){ + nbClient = 0; + for(int i = 0 ; inbClient); diff --git a/src/Stand_de_cuisson.java b/src/Stand_de_cuisson.java index cd5528b..6f10666 100644 --- a/src/Stand_de_cuisson.java +++ b/src/Stand_de_cuisson.java @@ -1,11 +1,30 @@ -public class Stand_de_cuisson { - private Cuisinier cuisinier; +import java.util.LinkedList; +import java.util.Queue; - Stand_de_cuisson(Cuisinier cuisinier){ - this.cuisinier = cuisinier; +public class Stand_de_cuisson { + private Queue clients = new LinkedList(); + + + //get le client en tête de queue + public synchronized Client getClient(){ + return clients.peek(); } - public synchronized void faire_cuire_plat(Client client){ - this.cuisinier.faire_cuire(client); + //supprime le client en tête de queue + public synchronized void nextClient(){ + clients.poll(); + } + + public synchronized void finir_cuit(){ + notifyAll(); + } + + public synchronized void ajouter_client(Client client){ + clients.add(client); + notifyAll(); + } + + public synchronized boolean containsClient(Client client){ + return this.clients.contains(client); } }