Articles

EasyRSS

Petite classe sortie du tiroir à poussière qui permet de lire un flux rss, de mettre en cache le contenu, et de l'afficher sur un site web.

package.png EasyRSS.zip (v1.0b Décembre 2006, ZIP 2,36 ko)

Qemu

Qemu Windows + Qemu Accelerated Driver

(from pendrive linux)

package.png Qemu_iso_launcher.zip (1,2 Mo, ZIP)

  1. Dezziper l'archive dans un dossier.
  2. Dans ce dossier, rajouter l'image disque ISO d'un OS (linux, windows, ...).
  3. Télécharger un disque dur virtuel : 2 Go ou 4 Go.
  4. Renommer le fichier casper-rw en casper-rw.img et déplacer le dans le dossier que vous avez dézzipé
  5. Lancer le fichier launch.bat pour lancer la machine virtuelle, qui va automatiquement booter sur les ISO trouvés.

[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).

[Java] Performances en Java - L'influcence du mot clé synchronized (1)

Le mot clé synchronized permet de s'assurer qu'une méthode ou un bloc de code se sera pas accédé par deux Thread en même temps. Pour plus de détails, voyez cet article sur Développez.com[htt.... Voici le test effectué :

public class SynchronizeBench {
 
    public SynchronizeBench() {
    }
 
    public void a() {
    }
 
    public synchronized void b() {
    }
 
    static void test(SynchronizeBench bench, boolean a) {
      int i = 500000;
      long time = System.currentTimeMillis();
      while (i > 0) {
        if (a) {
          bench.a();
        } else {
          bench.b();
        }
        i--;
      }
      time = System.currentTimeMillis() - time;
      System.out.println("Methode "+(a?"a":"b")+" : "+time+" ms");
    }
 
    public static void main(String[] args) {
      SynchronizeBench bench = new SynchronizeBench();
      test(bench, true);
      test(bench, false);
    }
 
  }

Résultats

  • Méthode a (sans synchronisation) : 0 miilisecondes
  • Méthode b (avec synchronisation) : entre 14 et 17 millisecondes

Conclusion

L'utilisation du mot clé synchronized ralenti en soi l'accès à une méthode.

page 13 de 22