Bloquer les éléments d'une liste pendant un laps de temps

**Foub** · 16/03/2008, 09h27

Bonjour,

je souhaite pouvoir bloquer/débloquer les éléments présents dans une java.util.List jusqu'à que l'utilisateur clique sur un bouton par exemple.

Par exemple, j'aimerais pouvoir écrire l'action suivante pour mon bouton : «

Code :

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

1
2
3
4
5
6
7
 
JButton btnDebloquer = new JButton("Débloquer situation !");
btnDebloquer.addActionListener(new ActionListener(){@Override
       public void actionPerformed(ActionEvent arg0) {
               maListe.setBloquer(false);
       }
});

».
Au démarrage du test (les éléments de la liste sont bloqués), si on essaye d'ajouter des éléments à ma liste, il faudrait que ces actions soient mis dans une file d'attente jusqu'à que je clique sur le bouton btnDebloquer pour autoriser l'accès à ma liste.

Savez-vous comment pourrais-je faire cela en java ?

J'ai essayé de me créer la classe "ArrayListPerso" : «

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
package listPerso;
 
import java.util.ArrayList;
 
public class ArrayListPerso<T> extends ArrayList<T> {
       /** Version de sérialisation */
       private static final long serialVersionUID = 1L;
 
       /** Bloquer l'ajout d'élement ? */
       private boolean bloquer = false;
 
       /**
        * Constructeur par défaut.
        */
       public ArrayListPerso() {
               super();
       }
 
 
       /**
        * Retourne un boolean pour indiquer si on bloque l'ajout d'élément
        * dans la liste.
        *
        * @return true la liste des éléments est bloqué, false on peut
modifier la liste.
        */
       public boolean isBloquer() {
               return bloquer;
       }
 
       /**
        * Définit l'état de la liste : bloque-t-on tout ajout d'élément ou
pas ?
        * @param bloquer true on bloque tout ajout d'élément, false on
autorise tout modification.
        */
       public void setBloquer(boolean bloquer) {
               if ((bloquer == false) && (this.bloquer == true)) {
                       this.bloquer = bloquer;
                       this.notifyAll();
               } else {
                       this.bloquer = bloquer;
               }
       }
 
       @Override
       public boolean add(T arg0) {
 
               if (bloquer) {
                       System.out.println("L'ajout de l'élément " + arg0 + " est
suspendu !");
                       try {
                               this.wait();
                       } catch (InterruptedException e) {
                               e.printStackTrace();
                       }
               }
 
               System.out.println("Ajout de l'élément " + arg0 + " effectué !");
               return super.add(arg0);
       }
}

»

et la classe de test : «

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
public static void main(String[] args) {
               try {
 
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
               } catch (Exception e) {
                       e.printStackTrace();
               }
 
               final ArrayListPerso<String> maListe = new ArrayListPerso<String>();
 
               JFrame frame = new JFrame();
               frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
               JButton btnDebloquer = new JButton("Débloquer situation !");
               btnDebloquer.addActionListener(new ActionListener(){@Override
                       public void actionPerformed(ActionEvent arg0) {
                               maListe.setBloquer(false);
                       }
               });
 
               frame.getContentPane().add(btnDebloquer, BorderLayout.CENTER);
               frame.pack();
               frame.setLocationRelativeTo(null);
               frame.setVisible(true);
 
 
               maListe.add("allo");
               maListe.setBloquer(true);
               maListe.add("coucou");
       }

».

Voici les informations affichées dans la console : «

Exception in thread "main" java.lang.IllegalMonitorStateException
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Object.java:485)

at listPerso.ArrayListPerso.add(ArrayListPerso.java:50)
at TestFabienListePerso.main(TestFabienListePerso.java:45)
Ajout de l'élément allo effectué !
L'ajout de l'élément coucou est suspendu !

»

alors que je souhaiterais avoir : «

Ajout de l'élément allo effectué !
L'ajout de l'élément coucou est suspendu !

», puis, quand je clique sur le bouton : «

Ajout de l'élément coucou effectué !

».

Merci d'avance pour votre aide.
F.

**Djakisback** · 16/03/2008, 13h22

Salut,
pourquoi tu colles des wait() et notifyAll(), en fait c'est pas ton thread que tu veux bloquer vu que tu veux utiliser un tampon ? Si j'ai bien compris tu dois pouvoir faire comme ceci :
1) ajouter un Vector buffer dans ta liste.
2)

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
 
public class ArrayListPerso<T> extends ArrayList<T> {
       /** Version de sérialisation */
       private static final long serialVersionUID = 1L;
 
       /** Bloquer l'ajout d'élement ? */
       private boolean bloquer = false;
 
       private Vector buffer;
 
       /**
        * Constructeur par défaut.
        */
       public ArrayListPerso() {
               super();
               this.buffer = new Vector();
       }
 
       public boolean isBloquer() {
               return bloquer;
       }
       public void setBloquer(boolean bloquer) {
           this.bloquer = bloquer;
           if(!bloquer)	{
        	   this.moveBufferToList();
           }
       }
 
       public void moveBufferToList()	{
    	   super.addAll(this.buffer);
    	   this.buffer.removeAllElements();
       }
 
       public boolean add(T arg0) {
               if (bloquer) {
            	   return this.buffer.add(arg0);
               }
               return super.add(arg0);
       }
}

Bye

**natha** · 16/03/2008, 19h20

Sinon c'est préférable de ne pas étendre ArrayList mais d'implémenter List et d'utiliser une ArrayList comme wrapper dans ta liste perso.
Sinon Vector ne devrait plus être utilisé, les bonnes pratiques indiquent qu'il faut synchroniser une liste (moins dépendant de l'implémentation).

En code pour être clair :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class BlocableList<T> implements List<T> {
 
       private List<T> wrapper = new ArrayList<T>();
 
       /** Bloquer l'ajout d'élement ? */
       private boolean bloquer = false;
 
       private List<T> buffer = Collections.synchronisedList(new ArrayList<T>());
 
       // implementation des méthodes de List en utilisant le wrapper
 
       // méthodes spécifiques de la BlocableList
 
}

L'avantage c'est que tu évites de donner l'accès à des méthodes spécifiques de ArrayList et que donc si un jour tu préfères utiliser une LinkedList par exemple, tu le fais en 1 ligne de code seulement sans le moindre problème.

**Djakisback** · 16/03/2008, 19h29

Sinon Vector ne devrait plus être utilisé, les bonnes pratiques indiquent qu'il faut synchroniser une liste (moins dépendant de l'implémentation).

Salut, peux-tu préciser ? Vector est syncro.

**natha** · 16/03/2008, 21h57

Envoyé par Djakisback

Salut, peux-tu préciser ? Vector est syncro.

http://www.developpez.net/forums/sho...41&postcount=9

En gros, utiliser une List (et de la déclarer en tant que telle avec uniquement l'interface List) permet de pouvoir changer d'implémentation facilement si un jour tu le souhaites, si tu utilises un Vector, tu seras beaucoup plus dépendant de cette classe (quoique maintenant Vector implémente List, mais il faut faire List list = new Vector() et non Vector v = new Vector()).