[Multiton] [Java] avec ou sans volatile et double check ?

Bonjour ,

Je voulais un patron qui ne permait qu'une seule instance d'une classe par id :
je suis tombé sur le patron Multiton :

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
 
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 ...
}

source

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:

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