Another Java Blog ...

Je viens de tomber là-dessus ... Je vous laisse regarder avant toute chose.

Voila, je viens de voir le film Sharkwater : les seigneurs de la mer. Un film réalisé, écrit et produit par le même homme : Rob Stewart. Un biologiste fasciné par la nature, et plus particulièrement par les requins. Au cours de ses voyages, il s'est rendu compte de la place primordiale qu'ils occupent dans l'océan et indirectement sur terre.

Le format du film : une sorte de docu-réalité d'1h30, pendant laquelle on suit Rob essayant tant bien que mal de sauver une espèce de l'extermination. Car c'est bien de cela qu'il est question, l'extermination des requins pour leurs ailerons. En effet, la soupe de poulet aux deux boeufs est encore meilleure si elle est agrémentée d'ailerons de requins. Cette soupe est un signe de richesse et une marque de respect pour ses invités dans les pays asiatiques consommateurs d'ailerons de requins. Un commerce extrèmement lucratif, de toute évidence, suffisamment lucratif pour que les mafias décident de s'en mêler.

Le film montre parfaitement les obstacles auxquels doivent faire face les ONG, les groupes de défenseurs des requins ou les individus souhaitant alerter les populations. La corruption exercée par diverses mafias afin de conserver ce commerce est si grande que les braconniers sont devenus quasiment intouchables.

Il insiste également sur le rôle des requins (qui sont là depuis ~400 millions d'années) dans la faune aquatique. Leur absence entrainerait un dérèglement de la chaine alimentaire ce qui aurait des conséquences directes sur les planctons (je ne suis pas sur de l'espèce?) responsables de la transformation de dioxyde de carbone et dioxygène.

Je ne compte pas vous faire un résumé du film ici. La seule raison d'être de cet article est de vous encourager à payer pour aller le voir, parler de Sharkwater et des nombreuses actions qui existent pour mettre fin à cette industrie barbare.

savingsharks.com


100 millions de requins sont tués tous les ans.

Variable : une donnée-membre private n'est accessible que depuis la classe où elle est définie. Afin de la modifier ou d'accéder à sa valeur, on utilise des accesseurs/mutateurs (getters/setters)


Méthode : une méthode private n'est accessible que depuis la classe où elle est déclarée.

Qu'est-ce qu'un objet Singleton ?

Un singleton est un objet qui ne doit être instancié qu'une seule fois, par exemple un objet qui gère la journalisation d'une application, un objet qui gère des paramètres d'une application ou bien un objet qui gère des pools de threads, ou des pools de connexion à une base de donnée. Tous ces objets ne doivent être instanciés qu'une seule fois tout en restant accessible à tout endroit du programme.

Une première approche

Voyons comment empêcher une classe d'être instanciée plusieurs fois ? Le code suivant est un premier exemple:

 public class MySingleton {

  /**
   * Création d'une donnée membre statique "instance"
   * Elle garde la référence de l'instance de classe MySingleton
   */
  private static MySingleton instance;

  /**
   * Constructeur par défaut de la classe
   */
  private MySingleton() {}

  /**
   * Méthode retournant  l'instance de la classe MySingleton
   * ou bien instancie la donnée-membre si elle est nulle
   */
  public static MySingleton getInstance() {
    if(instance == null) {
      instance = new MySingleton();
    }
    return instance;
  }

   //Autres méthodes
}

Ce code permet d'avoir une et une seule instance de l'objet MySingleton à tout endroit du programme. Pour récupérer cette instance, il suffira d'appeller la méthode getInstance de la classe MySingleton.

MySingleton mySingleton = MySingleton.getInstance();

Pour aller plus loin

Envisageons le cas d'une grosse application utilisant le multi-threading.

A un moment donné, il est possible d'avoir deux fils d'exécution qui, en se chevauchant appellent la méthode MySingleton.getInstance(). Si à ce moment, la donnée-membre instance est nulle, les deux threads vont exécuter le code instance = new MySingleton().

Il nous faut donc une méthode permettant de bloquer l'accès simultané des threads. Nous modifions deux éléments de notre précédente classe :

private volatile static MySingleton instance;

 public static MySingleton getInstance() {
  if(instance == null) {
    synchronized(MySingleton.class) {
       if(instance == null) {
         instance = new MySingleton();     
       }
    }
  }
  return instance;
}

La méthode synchronized empêche plusieurs fils d'exécution d'accéder à la méthode en même temps! Ainsi, chaque thread devra attendre son tour pour entrer dans le bloc d'instructions.
Voila, vous avez désormais un objet pour lequel vous êtes surs de n'avoir qu'une seule instance et accessible de n'importe quel endroit de votre programme.