Programmation concurrente et buffers
Bonjour à toutes et à tous,
Voilà je suis actuellement en train de concevoir un programme d'accès concurrent à des piles, et je fais face à un problème surement lié à ma compréhension partielle des threads.
Je dois implémenter deux buffers, et permettre à des threads d'accéder aux méthodes d'ajout et de suppression de ces derniers.
- Un premier buffer contient une Queue de commandes.
- Un second contient des plats issus de ces commandes.
- Un objet Cuisinier doit retirer du premier buffer une commande, la préparer (la préparation étant représenté par un sleep) et l'insérer une fois finie dans le deuxième buffer (le passe plat).
- Un objet Serveur doit récupérer dans le buffer "passe plat" un plat et le servir à un client (signifiant uniquement supprimer le plat du buffer).
Voilà où j'en suis :
Buffer :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
| public class FileAttente<Element> {
private Queue<Element> queue;
private Element element;
private boolean isEmpty = true;
public FileAttente()
{
queue = new LinkedList<Element>();
}
public FileAttente(Element[] tab)
{
queue = new LinkedList<Element>();
for (int i = 0; i < tab.length; i++)
{
queue.add(tab[i]);
}
}
public Queue<Element> getQueue()
{
return this.queue;
}
public synchronized Element retirer()
{
System.out.println("retirer");
while (isEmpty)
{
System.out.println("je suis dans le while");
try { wait(); System.out.println("j'attends pour retirer"); }
catch (InterruptedException e) {System.out.println("probleme"); }
}
System.out.println("j'enleve de la pile");
isEmpty = false;
notifyAll();
return queue.poll();
}
public synchronized void ajouter(Element elem)
{
element = elem;
queue.add(element);
notifyAll();
}
} |
Cuisinier :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
| public class Cuisinier<Element> implements Runnable {
private Thread thread;
private FileAttente<Element> file, fileCommande;
private String nomChef;
public Cuisinier(FileAttente<Element> f,FileAttente<Element> f2, String nom)
{
nomChef = nom;
file = f;
fileCommande = f2;
thread = new Thread(this);
thread.start();
}
@Override
public void run() {
Element plat;
for (int i = 0; i < fileCommande.getQueue().size(); i++)
{
try { Thread.sleep((int)(2000)); }
catch (InterruptedException e) { }
plat = fileCommande.retirer();
System.out.println(nomChef + " commence à préparer un " + plat);
try { Thread.sleep((int)(2000));}
catch (InterruptedException e) { }
file.ajouter(plat);
System.out.println(nomChef + " a déposé sur le passe plat un " + plat);
try { Thread.sleep((int)(2000));}
catch (InterruptedException e) { }
}
}
} |
Serveur :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
| public class Serveur<Element> implements Runnable {
private Thread thread;
private FileAttente<Element> file;
private String nomServeur;
public Serveur(FileAttente<Element> f, String nom)
{
nomServeur = nom;
file = f;
thread = new Thread(this);
thread.start();
}
@Override
public void run() {
Element plat = null;
for (int i = 0; i < file.getQueue().size(); i++)
{
try { Thread.sleep((int)(1000));}
catch (InterruptedException e) { }
plat = file.retirer();
System.out.println(nomServeur + " sert au client un " + plat);
}
}
} |
Main :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| public class TestFileAttente {
@SuppressWarnings("unused")
public static void main(String[] args) {
String[] plats = {"Boeuf Bourguignon", "Blanquette de veau", "Hachis Parmentier", "Poulet au Curris", "Salade piémontaise", "Brandade de morue", "Filet de Julienne", "Pot au feu"};
FileAttente<String> f = new FileAttente<String>(plats);
FileAttente<String> f2 = new FileAttente<String>();
Cuisinier<String> c1 = new Cuisinier<String>(f2, f, "Robuchon");
Serveur<String> s1 = new Serveur<String>(f, "Roger");
Serveur<String> s2 = new Serveur<String>(f, " René");
}
} |
Le problème est surement lié à la méthode wait de la classe FileAttente qui endort le thread cuisinier et le thread serveur, mais j'ai beau tourner la chose dans tout les sens, je ne vois pas comment remédier au problème.
Si une âme charitable ayant quelques minutes à perdre passe dans le coin et veut bien m'aider, je lui en serais reconnaissant.
Merci d'avance.
