[JAVA] Introduction aux modèles de conception (poids mouche)

Cet article résume Flyweight. Selon wikipedia, «Lorsque vous utilisez des instances équivalentes à différents endroits, vous pouvez économiser des ressources en réutilisant une instance». Référence: Flyweight pattern

** Personnages principaux **

Si vous souhaitez représenter une forêt par programme, vous générerez probablement un grand nombre d'instances d'arborescence. La génération d'une grande quantité consomme de la mémoire sur le serveur, mais c'est un modèle qui économise de la mémoire en réduisant le nombre d'instances à l'exécution. En Java, il y avait une méthode appelée String.intern comme plan de réglage pour l'économie de mémoire, mais je pense que l'idée (réutiliser des objets avec le même contenu) est presque la même.

** Implémentez le modèle ** Le but est simple et de réduire l'instanciation (nouveau dans le code source). Je vais l'implémenter avec l'exemple de wikipedia. Une certaine chaîne de caractères est définie caractère par caractère dans le type char, et si elle est déjà définie, elle sera réutilisée, et si elle n'est pas définie, elle sera générée.

** Classe poids mouche **

Stamp.java

class Stamp {
    char type;
    Stamp(char type){
        this.type = type;
    }
    void print(){
        System.out.print(this.type);
    }
}

** Classe FlyweightFactory **

StampFactory.java

import java.util.Map;
import java.util.HashMap;

class StampFactory {
    Map<Character, Stamp> pool;
    StampFactory(){
        this.pool = new HashMap<Character, Stamp>();
    }
    Stamp get(char type){
        Stamp stamp = this.pool.get(type);
        if(stamp == null) {
            stamp = new Stamp(type);
            this.pool.put(type, stamp);
        }
        return stamp;
    }
}

** Classe d'exécution **

FlyweightTest.java

import java.util.Map;
import java.util.List;
import java.util.ArrayList;

class FlyweightTest {
    public static void main(String[] args) {
        StampFactory factory = new StampFactory();
        List<Stamp> stamps = new ArrayList<Stamp>();
        stamps.add(factory.get('Ta'));
        stamps.add(factory.get('Ou'));
        stamps.add(factory.get('je'));
        stamps.add(factory.get('Ta'));
        stamps.add(factory.get('Ke'));
        stamps.add(factory.get('Ta'));
        stamps.add(factory.get('main'));
        stamps.add(factory.get('Ou'));
        stamps.add(factory.get('Ke'));
        stamps.add(factory.get('Ta'));
        for(Stamp s : stamps){
            s.print();
        }
    }
}

résultat

j'étais coincé

Si vous mettez dans un processus réutilisable qui réduit autant que possible l'utilisation de la mémoire, cela peut entraîner des rides dans la surcharge et les performances globales, vous devez donc identifier les points de chacun. Cependant, dans le cas du langage Java, afin de créer un objet, 2 octets sont consommés pour les caractères (type char) et 4 octets pour les entiers (type int). Si c'est un environnement auquel on accède en parallèle, même s'il est temporaire, l'utilisation augmentera plusieurs fois, donc je pense que c'est un événement (modèle) dont vous devriez être conscient.