Design patterns, Développement web

Les singletons : design pattern

Laisser un commentaire

Un singleton est un design pattern dont l’objet consiste à avoir une classe qui ne peut être instanciée qu’une seule fois.

Ce serait le cas typique de la configuration d’un site web. Il serait absurde de créer plusieurs objets configuration s’agissant d’un seul et même site web.

A chaque instanciation de Config, on ferait par exemple:

1
2
3
4
5
$config1 = new Config();

...

$config2 = new Config();

Un nouvel objet Config est créé à chaque fois. Ce qui nous arrange pas vraiment.

Une solution à ce problème serait de de créer une classe statique. Celle-ci n’ayant pas besoin d’être instanciée. Il s’avère cependant que ces classe statiques ne peuvent pas disposer de constructeur, de plus gérer l’héritage des classes statiques est assez complexe. (voir Late Static Bindings).

La solution consiste donc à créer une nouvelle instance de la classe seulement si aucune instance de cette classe n’a déjà été créée.

Supposons que notre classe Config soit chargée de gérer la configuration de notre application qui se trouve dans un fichier config/config.php.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?php

class Config {
  private $settings = [];
  private static $_instance;

  public static function getInstance(){
    if(is_null(self::$_instance)){
      self::$_instance = new Config();
    }
    return self::$_instance;
  }

  public function __construct(){
    $this->settings = require dirnam(__DIR__) . 'config/config.php';
  }
}

C’est donc dans la méthode :

1
2
3
4
5
6
public static function getInstance(){
    if(is_null(self::$_instance)){
      self::$_instance = new Config();
    }
    return self::$_instance;
  }

que l’instance de Config est créée. On voit bien ici, que Config n’est instancié que s’il n’existe pas encore d’objet.

A chaque endroit où j’ai besoin de ma configuration, je l’appelle de cette manière

1
$config = Config::getInstance();

De cette façon, l’objet Config n’est créé que s’il n’a pas déjà été préalablement instancié .

Système

Communication inter-Threads en utilisant une FIFO thread-safe

Laisser un commentaire

But de l’application

L’application consiste à créer trois threads et à les faire communiquer en utilisant une FIFO thread-safe.

Le premier thread

1
LireFichier();

charge le contenu d’un fichier texte et envoie les caractères lus dans une FIFO.

Le second thread

1
calculer();

récupère les caractères présents dans la première FIFO et convertit les caractères minuscules en majuscule puis les envoie dans une seconde FIFO.

Le troisième thread

1
afficher();

est chargé de récupérer les caractères de la seconde FIFO et de les afficher à l’écran.

Organisation du code


Le programme comporte un fichier

1
main.c

qui contient les corps de 3 fonctions

1
LireFichier(); calculer(); et afficher();

qui vont constituer nos threads.

Les fichiers

1
tfile.h et tfile.c

contiennent les déclarations et les corps des fonctions utilisés par notre FIFO circulaire thread-safe.

Le thread

1
LireFichier();

ouvre un fichier texte, et enfile les caractères lus dans la FIFO jusqu’à la fin du fichier. Lorsque un caractère ne peut pas être enfilé, il sera à nouveau enfilé lors de l’occurrence suivante de la boucle. Lorsque la fin du fichier est atteint, le thread enfile un caractère « null » pour signaler la fin du fichier.

Le thread

1
calculer()

défile les caractères contenus dans la FIFO, convertit les caractères minuscules en majuscule et les enfile dans la seconde FIFO. Lorsque le thread rencontre un caractère « null », il l’enfile puis se termine.

Le thread

1
afficher()

défile les caractères contenus dans le seconde FIFO et les affiche à l’écran. Lorsqu’il rencontre le caractère « null », il se termine.
Notre structure s_file est une file circulaire doublement chaînée dans un tableau. Elle comporte un tableau de caractères, un pointeur de tête et un pointeur de queue. Un mutex permet de délimiter les sections critiques et deux sémaphores sont utilisées comme compteur d ‘entrée et compteur de sortie qui vont permettre de limiter le contenu de la file.

La fonction

1
initQueue()

initialise le sémaphore sem_f avec la valeur de la taille de la file. Le sémaphore sem_e est initialisé à 0. Le mutex et les pointeurs de tête et de queue sont aussi initialisés par cette fonction.

La fonction

1
push()

enfile un caractère. Le sémaphore sem_f est décrémenté à chaque appel. Lorsque la file est pleine, la valeur du sémaphore est nulle et la thread est bloquée. Ceci empêche la file de se remplir au delà de sa taille. L’ajout du caractère dans la file et la modification des pointeurs de tête et de queue sont effectués dans une section critique protégée par le mutex afin que plusieurs modifications simultanées ne soient pas possibles. Ensuite, le sémaphore sem_e est incrémenté. Ce qui va permettre d’indiquer que la file contient des caractères. Finalement, le mutex est débloqué et le thread se termine.

La fonction

1
pull()

défile un caractère. Le sémaphore sem_e est décrémenté lorsque un caractère est défilé et bloque le thread lorsque la file est vide. La lecture et la modification des pointeurs de file sont réalisées dans une section critique protégée par le mutex. La valeur est retournée et le sémaphore sem_f est incrémenté. Le mutex est libéré et le thread se termine.

Diagramme temporel de sem_e

Diagramme temporel de sem_f

Rappel sur les types de sémaphores :

  • Sémaphore binaire : Il est initialisé à 0 et permet de synchroniser deux threads. En effet, une instruction
1
sem_wait();

va interrompre le thread. L’instruction

1
sem_post();

dans un autre thread va libérer le thread interrompu. Nous utilisons un sémaphore binaire sem_e.

  • Sémaphore utilisé comme mutex : Il est initialisé à 1 il se comporte comme un mutex.

Une instruction

1
sem_wait()

débute une section critique et une instruction

1
sem_post()

la termine. Nous n’utilisons pas ce type de sémaphore dans notre programme mais nous utilisons un mutex.

  • Sémaphore utilisé comme compteur : Il est initialisé à une valeur N supérieure à 1. Il protège l’accès à une ressource de taille N. Nous utilisons ce type de sémaphore afin de protéger notre FIFO.

Nous utilisons ici un sémaphore binaire sem_e initialisé à 0.

1
2
sem_t sem_e; //déclaration
sem_init(&amp;t-&gt;sem_e,0,0); //initialisation

Ce sémaphore va empêcher que le thread défile un caractère lorsque la file est vide. Il est incrémenté à chaque ajout de caractères dans la file.

Développement web

L’autoloading dans PHP

Laisser un commentaire

L’autoloading permet de charger automatiquement les classes.

Au lieu d’ajouter un

1
require 'className.php';

à chaque fois que l’on a besoin d’une classe, on va créer un autoloader qui charge automatiquement les classes.

Pour créer un autoloader qui charge les classes à chaque fois qu’il rencontre une directive new comme dans :

1
new className();

nous devons d’abord créer la fonction:

1
2
3
function __autolad($class_name){
   require 'class/' . $class_name . '.php';
}

dès à présent nous n’avons plus besoin d’utiliser de

1
require 'className.php';

C’est l’autoloader qui s’en charge maintenant d’inclure la déclaration de la classe.

L’inconvénient ici, c’est que toutes les classes doivent se trouver dans le dossier class/ et il n’est pas possible de déclarer d’autre autoloaders

La solution pour remédier à ce problème consiste ici à déclarer l’autoloader de cette manière

1
2
3
function myAutoloader($class_name){
   require 'class/' . $class_name . '.php';
}

et d’utiliser la fonction

1
spl_autoloader_register('myAutoloader');

qui enregistre la fonction myAutoloader() dans la pile __autoload()

Nous pourront ainsi déclarer plusieurs autoloaders

Une idée encore meilleure ici est de créer une classe Autoloader

1
2
3
4
5
6
7
8
class Autoloader {
 static function register(){
  spl_autoload_register(array(__CLASS__,'autoload'));
 }
 static function autoload($class_name){
  require 'class/' . $class_name . '.php';
 }
}

Il faudra ensuite inclure uniquement la classe Autoloader et appeler notre méthode register de Autoloader

1
2
require 'class/autoloader.php';
Autoloader::register();

avant d’instancier nos classes.

De cette manière, il ne sera plus nécessaire d’inclure les déclarations de classes et il sera possible d’inclure d’autres autoloaders.