Discussion :

[kev85270]

Bonjour à tous,
Dans le cadre d'un TP de programmation java multithread, je doit implémenter une file bloquante bornée.
Seulement je n'ai aucune idée, je ne vous demande pas de faire tout le code, juste de m'expliquer comment faire si possible.
Merci d'avance

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
 
package prog2.concur.exercice2;
 
import java.lang.reflect.Array;
import java.util.ArrayList;
 
/**
 * Une file de communication bornee bloquante.
 *
 * Les threads peuvent déposer (resp. prendre) des objets dans une telle file.
 * Cette opérations peut être bloquante si la file est pleine (resp. vide).
 */
public abstract class AbstractFileBloquanteBornee<E>
{
 
    protected E[] tableau;
    protected int tete;
    protected int queue;
    protected boolean estVide;
    protected boolean estPleine;
 
    /**
     * Créer une file de capacité maximale n.
     *
     * param n - la capacité maximale de la file.
     * n devrait être supérieur ou égal à 1.
     */
    @SuppressWarnings({"unchecked"})
    public AbstractFileBloquanteBornee (int n) throws IllegalArgumentException 
    {
        if(n<1) 
            throw new 
                IllegalArgumentException(
                        "AbstractFileBloquanteBornee : la capacité de la file doit être > 0");
        else {
            /* Création d'un tableau pseudo-générique.
             * Fonctionne tant que le tableau reste "interne" à la classe.
             * Cf. http://stackoverflow.com/questions/529085/how-to-generic-array-creation
             */
            tableau = (E[]) new Object[n];
            tete = queue = 0;
            estVide = true;
            estPleine = false;
        }
    }
 
    /**
     * Déposer une référence dans la file.
     *
     * Le dépôt est fait en fin de file.
     * L'objet référencé n'est pas copié au moment du dépôt.
     * Le dépôt est bloquant lorsque la file est pleine
     *
     * param e - l'élément à ajouter à la file
     */
     abstract public void deposer (E e) throws InterruptedException;
     {
 
     }
 
    /**
     * Prendre une référence dans la file.
     *
     * La prise est faite en tête de file.
     * L'objet référencé n'est pas copié au moment du dépôt.
     * La prise est bloquante lorsque la file est vide.
     *
     * returns la référence de tête de la file
     */
    abstract public E prendre () throws InterruptedException;
    {
 
    }
    public static void main(String[] args) 
    {
 
 
	}
}

[tchize_]

Qu'est-ce qui te bloque dans l'histoire?

[awane]

Hello kev85270,

Je pense que ton TP consiste à concevoir une queue bloquante comme celle du JDK.
Si tu ne sais pas par ou commencer, essaye de te documenter du côté de BlockingQueue et inspire toi de la classe ArrayBlockingQueue<E> du JDK.

Voici quelques liens utiles :
http://tutorials.jenkov.com/java-uti...kingqueue.html

http://www.javamex.com/tutorials/blo..._example.shtml

Bon courage.
Awane

[thelvin]

Je pense que ton TP consiste à concevoir une queue bloquante comme celle du JDK.
Si tu ne sais pas par ou commencer, essaye de te documenter du côté de BlockingQueue et inspire toi de la classe ArrayBlockingQueue<E> du JDK.

Pour un exercice c'est peut-être un peu compliqué quand même. Les implémentations du JDK évitent les synchronisations autant que possible pour optimiser les performances multithreadées, mais au prix d'une architecture nettement plus compliquée.

Il est probable que l'exercice ne consiste qu'à déclarer les méthodes synchronized, et utiliser wait() et notifyAll().