Discussion :

[Gaetch]

Bonjour,

j'aimerais bien qu'on m'explique à quoi sert le design pattern support d'initialisation à la demande (initialization on demand holder). Je n'ai pas trop compris la différence avec le simple singleton.

Singleton :

Code :

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

1
2
3
4
5
6
public class Singleton
{
  private static final Singleton INSTANCE = new Singleton();
  private Singleton() {}
  public static Singleton getInstance() {return INSTANCE;}
}

Initialization on demand holder :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
public class Singleton
{
  private Singleton() {}
  private static class SingletonHolder
  {
    public static final Singleton INSTANCE = new Singleton();
  }
  public static Singleton getInstance()
  {
    return SingletonHolder.INSTANCE;
  }
}

Je sais que les variables static sont initialisées à l'initialisation de la classe et qu'en mettant INSTANCE à l'intérieur d'une méthode, cette initialisation n'a donc pas lieu en même temps que celle de la classe mais seulement à l'appel de getInstance(). Mais ça change quoi ?

J'ai cru comprendre que c'était pour éviter que deux threads concurrents ne puissent se retrouver avec des instances différentes su Singleton, mais là j'ai pas compris comment...

[Yo Eight]

Dans ton premiere exemple ton instance de la classe Singleton aura déjà été instancié quand tu feras un appel sur la méthode getInstance. Ce qui veux dire que si tu as des traitements lourds qui sont effectués dans le constructeur de Singleton, tu ralentis le démarrage de ton application.

Dans ton second exemple, les traitements lourd ne seront fait que lorsque l'on fera appel à la méthode getInstance.

En parlant d'accès concurrent, je ne trouve pas que ton singleton soit thread-safe.

Voici plutôt un singleton thread-safe:

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
 
public class Singleton{
    private volatile static Singleton instance;
    private Singleton(){}
 
    public static Singleton getInstance() {
       if(instance == null){
          synchronized(Singleton.class){
             if(instance == null){
                instance = new Singleton();
             }
          }
       }
 
        return instance;
    }
}

[Gaetch]

Les traitements lourds seront faits quoiqu'il arrive, non ?

Dans ton code, que fait synchronized(Singleton.class) ? Pourquoi tester if(instance == null) deux fois ?

[Yo Eight]

Ce code effectue une double vérification.
Le mot clé synchronized permet de garantir qu'un seul thread accède à ce code à la fois. Le problème, c'est qu'il est très couteux d'où la double vérification. Si j'ai déjà une instance, pas la peine de synchroniser.

De plus, s'il y a des traitements lourds dans le constructeur de la classe. Le chargement se fera que lorsque l'on a besoin => Chargement de l'application plus rapide