[JAVA] Einführung in Designmuster (Fliegengewicht)

Dieser Artikel fasst das Fliegengewicht zusammen. Laut Wikipedia "spart das Programm Ressourcen, wenn äquivalente Instanzen an verschiedenen Orten verwendet werden, indem eine Instanz wiederverwendet wird." Referenz: Fliegengewichtsmuster

** Hauptcharaktere **

Wenn Sie eine Gesamtstruktur programmgesteuert darstellen möchten, generieren Sie wahrscheinlich eine große Anzahl von Bauminstanzen. Das Generieren einer großen Menge verbraucht Speicher auf dem Server, aber es ist ein Muster, das Speicher spart, indem die Anzahl der Instanzen zur Laufzeit reduziert wird. In Java gab es eine Methode namens String.intern als Optimierungsplan für die Speichereinsparung, aber ich denke, dass die Idee (Wiederverwendung von Objekten mit demselben Inhalt) fast dieselbe ist.

** Implementiere das Muster ** Der Zweck ist einfach und um die Instanziierung zu reduzieren (neu im Quellcode). Ich werde es am Beispiel von Wikipedia implementieren. Eine bestimmte Zeichenfolge wird zeichenweise im Zeichentyp definiert. Wenn sie bereits definiert ist, wird sie wiederverwendet. Wenn sie nicht definiert ist, wird sie generiert.

** Fliegengewichtsklasse **

Stamp.java

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

** FlyweightFactory Klasse **

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;
    }
}

** Ausführungsklasse **

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('Oder'));
        stamps.add(factory.get('ich'));
        stamps.add(factory.get('Ta'));
        stamps.add(factory.get('Ke'));
        stamps.add(factory.get('Ta'));
        stamps.add(factory.get('Hand'));
        stamps.add(factory.get('Oder'));
        stamps.add(factory.get('Ke'));
        stamps.add(factory.get('Ta'));
        for(Stamp s : stamps){
            s.print();
        }
    }
}

Ergebnis

Ich wurde geschlagen

Wenn Sie einen wiederverwendbaren Prozess einsetzen, der die Speichernutzung so weit wie möglich reduziert, kann dies zu Falten im Overhead und in der Gesamtleistung führen. Daher müssen Sie die einzelnen Punkte identifizieren. Im Fall der Java-Sprache werden jedoch zum Erstellen eines Objekts 2 Bytes für Zeichen (Char-Typ) und 4 Bytes für Ganzzahlen (Int-Typ) verbraucht. Wenn es sich um eine Umgebung handelt, auf die parallel zugegriffen wird, auch wenn sie nur vorübergehend ist, wird die Nutzung um ein Vielfaches zunehmen. Ich denke, es ist ein Ereignis (Muster), das Sie kennen sollten.