Bonjour ,
Je voulais un patron qui ne permait qu'une seule instance d'une classe par id :
je suis tombé sur le patron Multiton :
source
Code java : 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 public class FooMultiton { private static final Map<Object, FooMultiton> instances = new HashMap<>(); private FooMultiton() { // no explicit implementation } public static synchronized FooMultiton getInstance(Object key) { // Our "per key" singleton FooMultiton instance = instances.get(key); if (instance == null) { // Lazily create instance instance = new FooMultiton(); // Add it to map instances.put(key, instance); } return instance; } // other fields and methods ... }
qui correspond à ce que je veux
néhanmoins, connaissant le patron singleton je me demande si c'est optimal
ne faudrait-il pas faire :
Code Java : 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 public class FooMultitonPerso { private static volatile Map<Object, FooMultitonPerso> instances = new HashMap<>(); private FooMultitonPerso() { // no explicit implementation } public static FooMultitonPerso getInstance(Object key) { FooMultitonPerso instance = instances.get(key); if (instance == null) { synchronized(FooMultitonPerso.class) { // ou synchronized(instances) { est-ce équivalent dans ce cas ? instance = instances.get(key); if(instance == null) { instance = new FooMultitonPerso(); instances.put(key, instance); } } } return instance; } // other fields and methods ... }
de cette manière la synchronization, couteuse en temps, n'est utilisée que si réellement nécéssaire et pas systématiquement comme dans la méthode FooMultiton.getInstance proposée par wikipedia.
Mais en ce qui concerne FooMultitonPerso
1) est-ce que ce code est bien thread safe ?
2) et est-il plus performant que FooMultiton ?
3) faut-il mieux faire la synchronisation sur FooMultitonPerso.class ou instances ?
merci d'avance
Partager