Discussion :

[totot]

Bonjour,

J'ai une liste qui peut être utilisé par 2 personnes en même temps : l'une qui ajoute un élément dedans, l'autre qui la parcours.

Comment faire pour éviter les accès concurrents et dire que la personne doit attendre que l'autre personne ai fini sont traitement avec la liste?

J'avais pensez au mot clé synchronized mais je vois pas trop comment mettre cela en place

[joel.drigo]

Salut,

Oui, le mot synchronized sert à ça. Tu peux synchroniser les méthodes ou les blocs.

Par exemple, sur les méthodes, tout simplement :

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 Exemple {
 
    private final List<String> list = new ArrayList<>();
 
    public synchronized void add(String value) {
           list.add(value);
    }
 
    public synchronized void remove(String value) {
           list.remove(value);
    }
 
 
}

Par exemple, sur les blocs, tout simplement :

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
public class Exemple {
 
    private static final List<String> list = new ArrayList<>();
 
    public static void add(String value) {
           synchronized(list) {
                  list.add(value);
           }
    }
 
    public static void remove(String value) {
           synchronized(list) {
                  list.remove(value);
           }
    }
 
 
}

Tu peux également rendre une liste "synchronisée" :

Code :

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

List<String> list = java.util.Collections.synchronizedList(new ArrayList<>());

Attention, toutefois, aux itérations et à certaines boucles de parcours similaires : cette synchronisation n'empêchera pas les risques de "concurrent modification exception", car c'est l'ensemble de la boucle qu'il faut mettre dans un bloc syncrhonisé (il ne doit pas y avoir de modification des éléments de la liste pendant le parcours).

[adiGuba]

Salut,


Ne pas oublier non plus :

• Les ReadWriteLock qui permettent de faire de la synchronisation plus fine en permettant à plusieurs threads d'accéder à une même ressource en "lecture" (puisque c'est uniquement l’écriture qui doit être exclusive).
• Le package java.util.concurrent qui propose plusieurs implémentations de collections qui gèrent la concurrente, comme par exemple ConcurrentLinkedQueue pour une queue FIFO.

a++

[Gugelhupf]

Salut,

N'hésite pas à étudier le "modèle producteur/consommateur" de la programmation concurrente.

A+