Modèle de poids mouche en Java

introduction

Présentation des modèles de conception de [GoF](https://ja.wikipedia.org/wiki/Gang of for _ (Information Engineering)) ["Introduction aux modèles de conception appris dans le langage Java augmenté et révisé"]( https://www.amazon.co.jp/ Édition révisée supplémentaire Introduction aux modèles de conception appris en langage Java-Yuki-Hiroshi / dp / 4797327030 / ref = pd_lpo_sbs_14_t_0? _ Encoding = UTF8 & psc = 1 & refRID = 2ZE4GPYNN55JGDR5QMHP) Je vais résumer sur.

Modèle de poids mouche

Qu'est-ce que Flyweight

C'est un cours de boxe léger, "fly class". La classe légère signifie «légèreté», ce qui signifie qu'elle consomme moins de mémoire. Pour créer un objet, il est nécessaire d'en faire un nouveau et d'allouer de la mémoire (instanciation), mais la création de nombreux objets consomme beaucoup de mémoire et ralentit le traitement. Pour résoudre ces problèmes, il est conseillé de l'utiliser à plusieurs reprises pour des instances déjà nouvelles. Un modèle qui supprime la consommation de mémoire en partageant ** des objets sans en créer autant que possible ** est appelé un ** modèle Flyweight **.

Personnage

Le modèle Flyweight est utilisé par les classes qui apparaissent dans le diagramme de classes ci-dessous. image.png

Classe d'implémentation

Exemple concret

À titre d'exemple concret, nous expliquerons en nous basant sur la classe suivante. image.png

Classe d'implémentation

Stamp.java


package sample;

public class Stamp {
	//lettre
	private char charname;
	//Nombre de fois d'utilisation
	private int useCount = 0;
	//Nombre de générations
	private int newCount = 0;

	public int getUseCount() {
		return useCount;
	}

	public void setUseCount(int useCount) {
		this.useCount = useCount;
	}

	public int getNewCount() {
		return newCount;
	}

	public void setNewCount(int newCount) {
		this.newCount = newCount;
	}

	//constructeur
	public Stamp(char charname) {
		this.charname = charname;
	}

	//Afficher les caractères
	public void print() {
		System.out.println("charname:" + this.charname);
	}
}

La classe Stamp est une classe Flyweight partagée et utilisée. Il reçoit le caractère «charname», est généré et imprime le caractère avec la méthode «print». De plus, bien que les champs soient fournis pour que le nombre d'utilisations (ʻuseCount) et le nombre de générations (newCount`) puissent être facilement compris, ils ne sont pas obligatoires.

StampFactory.java


package sample;

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

public class StampFactory {
	//Gérer les instances de Stamp déjà générées
	private HashMap<String, Stamp> pool = new HashMap<>();
	//Motif singleton
	private static StampFactory singleton = new StampFactory();

	//constructeur
	private StampFactory() {
	}

	//Obtenir une instance singleton
	public static StampFactory getInstance() {
		return singleton;
	}

	//Instanciation de timbre(partager)
	public synchronized Stamp getStamp(char charname) {
		//Clé(lettre)Valeur associée à(Instance de timbre)Obtenir
		Stamp bc = pool.get("" + charname);
		//Clé(lettre)Valeur associée à(Instance de timbre)Si n'a pas pu être obtenu
		if (bc == null) {
			//Créez une instance de Stamp ici
			bc = new Stamp(charname);
			//Comptez le nombre de nouveaux
			bc.setNewCount(bc.getNewCount() + 1);
			//Magasin dans HashMap
			pool.put("" + charname, bc);
		}
		//Comptez le nombre d'utilisations indépendamment de la présence ou de l'absence de nouveau
		bc.setUseCount(bc.getUseCount() + 1);
		return bc;
	}

	//Sortie de toutes les instances de Stamp gérées par HashMap
	public void printAllPool() {
		for (Entry<String, Stamp> entry : pool.entrySet()) {
			System.out.println(
					entry.getKey() + " : " + entry.getValue().getUseCount() + " : " + entry.getValue().getNewCount());
		}
	}
}

Cette classe sert de FlayweightFactory, qui est l'usine qui génère la classe Stamp. Il a un champ pool comme carte pour gérer les instances générées, et un champ singleton qui se représente car il applique ici le modèle Singleton. Pour utiliser cette classe, appelez d'abord la méthode getInstance de l'extérieur pour renvoyer l'instance StampFactory qui se représente elle-même. Ensuite, pour l'instance StampFactory retournée, appelez la méthode getStamp avec charname comme argument. Si une instance Stamp avec le charname passé comme argument en tant que clé a déjà été créée, elle sera obtenue à partir de pool, mais si l'instance n'a pas encore été créée, une instance sera créée et stockée dans pool. Faire. De plus, lorsqu'une instance est créée, elle est incrémentée de newCount et en incrémentant ʻuseCount, que l'instance soit créée ou non, le nombre de générations et l'utilisation de chaque instance de Stamp sont comptés. De plus, printAllPool` est implémenté comme une méthode pour sortir toutes les instances de Stamp stockées dans le pool. Le contenu à sortir est "Caractères clés: Nombre d'utilisations: Nombre de générations".

Classe d'exécution

Main.java


package sample;

import java.util.ArrayList;

public class Main {
	public static void main(String[] args) {
		//Préparation de l'instance de tampon
		StampFactory factory = StampFactory.getInstance();
		ArrayList<Stamp> stamps = new ArrayList<>();
		stamps.add(factory.getStamp('a'));
		stamps.add(factory.getStamp('b'));
		stamps.add(factory.getStamp('c'));
		stamps.add(factory.getStamp('f'));
		stamps.add(factory.getStamp('e'));
		stamps.add(factory.getStamp('a'));
		stamps.add(factory.getStamp('b'));
		stamps.add(factory.getStamp('c'));
		stamps.add(factory.getStamp('d'));
		stamps.add(factory.getStamp('f'));
		stamps.add(factory.getStamp('a'));
		for (Stamp s : stamps) {
			s.print();
		}
		System.out.println("-------------------------------");
		System.out.println("charname : useCount : newCount");
		//Sortie de toutes les instances de Stamp gérées par HashMap
		factory.printAllPool();
	}
}

C'est une classe qui sert de client qui utilise Flyweight et FlyweightFactory. En appelant la méthode getInstance, qui est une méthode statique de la classe StampFactory, pour obtenir l'instance stampFactory, et en appelant la méthode getStamp pour l'instance stampFactory obtenue, l'instance stamp est stockée dans le champ pool. Enfin, en appelant printAllPool (), tous les champs du pool sont affichés.

Résultat d'exécution

Le résultat de l'exécution de Main.java est le suivant. Même pour les caractères dont ʻuseCount est supérieur à 1, le newCount` n'est qu'une seule fois, indiquant que l'instance est réutilisée.

Résultat d'exécution


charname:a
charname:b
charname:c
charname:f
charname:e
charname:a
charname:b
charname:c
charname:d
charname:f
charname:a
-------------------------------
charname : useCount : newCount
a : 3 : 1
b : 2 : 1
c : 2 : 1
d : 1 : 1
e : 1 : 1
f : 2 : 1

Avantages et inconvénients

En utilisant le modèle Flyweight, vous pouvez réduire le nombre de nouveaux objets et économiser de la mémoire. En revanche, l'inconvénient est que les objets stockés dans le pool ne sont pas soumis au garbage collection et restent en mémoire, il est donc nécessaire de les gérer intentionnellement pour ne pas manquer de mémoire.

Résumé

Vous avez découvert le modèle Flyweight, qui réduit la consommation de mémoire en partageant des instances. L'exemple de code est téléchargé ci-dessous, veuillez donc vous y référer si vous le souhaitez.

En outre, d'autres modèles de conception sont résumés ci-dessous, veuillez donc vous y référer également.

Les références

Recommended Posts

Modèle de poids mouche en Java
Modèle de façade en Java
Motif singleton en Java
Modèle d'observateur en Java
Modèle d'itérateur en Java
Modèle de décorateur en Java
Modèle de prototype en Java
Modèle de proxy en Java
Modèle de méthode de modèle en Java
Modèle de chaîne de responsabilité en Java
Apprenez le modèle de conception "Flyweight" en Python
Motif singleton en Python
Autorisations Linux sur Java
Utiliser DataFrame en Java
Modèle de visiteur en Python
Mettre en œuvre un test piloté par table en Java
Détectez et traitez les signaux en Java.
Changez le modèle Flyweight en Pythonic (?) (3)
Changez le modèle Flyweight en Pythonic (?) (2)
Implémenter le modèle Singleton en Python
Changez le modèle Flyweight en Pythonic (?) (1)
Mise en œuvre du tri à bulles en Java (BubbleSort)
Résumé du modèle de conception Java GoF
Chevauchement d'expressions régulières en Python et Java
Apprenez le modèle de conception "Prototype" avec Python
Apprenez le modèle de conception "Builder" avec Python
Apprenez le modèle de conception "Observer" en Python
Apprenez le modèle de conception "Memento" avec Python
Apprenez le modèle de conception "Proxy" en Python
Rendement Python express en JavaScript ou Java
Appliquer le formateur Google Java Style avec IntelliJ
Apprenez le modèle de conception "Commande" en Python
Différences entre la syntaxe Python et Java
Recevoir des e-mails à l'aide de l'API Gmail en Java
Apprenez le modèle de conception "Visiteur" avec Python
Apprenez le modèle de conception "Bridge" avec Python
Apprenez le modèle de conception "Mediator" avec Python
Apprenez le modèle de conception "Décorateur" avec Python
Apprenez le modèle de conception "Iterator" avec Python
Apprenez le modèle de conception «Stratégie» avec Python
Apprenez le modèle de conception "Composite" avec Python
Apprenez le modèle de conception "État" en Python
Lançons le script Bash en Java
Apprenez le modèle de conception "Adapter" avec Python