[Java] Performances en Java - Singleton et synchronisation

Test du pattern Singleton, avec la notion d'accès synchronisés. Ce test met en œuvre trois solutions :

• La classe A utilise un getInstance synchronisé
• La classe B utilise un getInstance non-synchronisé, où seul la partie d'instanciation est synchronisée
• La classe C ne se soucie pas de la synchronisation car l'instantiation est statique

 public class SynchronizeBench2 {

   static class A {
     private static A instance = null;
     private A() {
       System.out.println("New A");
     }
     public static synchronized A getInstance() {
       if (instance == null) {
         instance = new A();
       }
       return instance;
     }
   }

   static class B {
     private static B instance = null;
     private B() {
       System.out.println("New B");
     }
     public static B getInstance() {
       if (instance == null) {
         synchronized (B.class) {
           if (instance == null) {
             instance = new B();
           }
         }
       }
       return instance;
     }
   }

   static class C {
     private static C instance = new C();
     private C() {
       System.out.println("New C");
     }
     public static C getInstance() {
       return instance;
     }
   }

   public static void main(String args) {
 
     int i = 10000000;
     long time = System.currentTimeMillis();
     while (i > 0) {
       A.getInstance();
       i--;
     }
     System.out.println("Test A : "+(int)(System.currentTimeMillis()-time)+" ms");
 
     i = 10000000;
     time = System.currentTimeMillis();
     while (i > 0) {
       B.getInstance();
       i--;
     }
     System.out.println("Test B : "+(int)(System.currentTimeMillis()-time)+" ms");
 
     i = 10000000;
     time = System.currentTimeMillis();
     while (i > 0) {
       C.getInstance();
       i--;
     }
     System.out.println("Test C : "+(int)(System.currentTimeMillis()-time)+" ms");
 
   }
 
 }

Résultats

• Classe A : entre 327 et 350 millisecondes
• Classe B : entre 62 et 73 millisecondes
• Classe C : entre 94 et 109 millisecondes

On remarque que la première solution est de loin la plus mauvaise : synchroniser la méthode entière oblige la machine virtuelle a mettre en œuvre le principe de synchronisation à chaque appel, ce qui dégrade les performances. La seconde méthode est bien meilleure, le bloc synchronisé étant accédé uniquement si l'instance n'a pas été crée. Bizarrement, la dernière méthode n'est pas la plus performante alors que théoriquement elle devrais être la plus rapide (moins de test et pas de synchronisation).