Flyweight pattern

Flyweight is a software design pattern. A Flyweight is an object that minimizes memory occupation by sharing as much data as possible with other similar objects; it is a way to use objects in large numbers when a simple representation would use an unacceptable amount of memory. Often some parts of the object state can be shared and it's common to put them in external data structures and pass them to the flyweight objects temporarily when they are used.

A classic example usage of the flyweight pattern are the data structures for graphical representation of characters in a word processor. It would be nice to have, for each character in a document, a glyph object containing its font outline, font metrics, and other formatting data, but it would amount to hundreds or thousands of bytes for each character. Instead, for every character there might be a reference to a flyweight glyph object shared by every instance of the same character in the document; only the position of each character (in the document and/or the page) would need to be stored externally.

Examples

The following programs illustrate the document example given above: the flyweights are called FontData in the Java example and GraphicChar in the C# example.

The examples illustrate the Flyweight pattern used to reduce memory by loading only the data necessary to perform some immediate task from a large Font object into a much smaller FontData (Flyweight) object.

Java

public enum FontEffect {

   BOLD, ITALIC, SUPERSCRIPT, SUBSCRIPT, STRIKETHROUGH

}

public final class FontData {

   /**

    * A weak hash map will drop unused references to FontData.

    * Values have to be wrapped in WeakReferences,

    * because value objects in weak hash map are held by strong references.

    */

   private static final WeakHashMap> flyweightData =

       new WeakHashMap>();

   private final int pointSize;

   private final String fontFace;

   private final Color color;

   private final Set effects;

   private FontData(int pointSize, String fontFace, Color color, EnumSet effects) {

       this.pointSize = pointSize;

       this.fontFace = fontFace;

       this.color = color;

       this.effects = Collections.unmodifiableSet(effects);

}

   public static FontData create(int pointSize, String fontFace, Color color,

       FontEffect... effects) {

       EnumSet effectsSet = EnumSet.noneOf(FontEffect.class);

       for (FontEffect fontEffect : effects) {

           effectsSet.add(fontEffect);

}

       // We are unconcerned with object creation cost, we are reducing overall memory consumption

       FontData data = new FontData(pointSize, fontFace, color, effectsSet);

       if (!flyweightData.containsKey(data)) {

           flyweightData.put(data, new WeakReference (data));

}

       // return the single immutable copy with the given values

       return flyweightData.get(data).get();

}

   @Override

   public boolean equals(Object obj) {

       if (obj instanceof FontData) {

           if (obj == this) {

               return true;

}

           FontData other = (FontData) obj;

           return other.pointSize == pointSize && other.fontFace.equals(fontFace)

               && other.color.equals(color) && other.effects.equals(effects);

}

       return false;

}

   @Override

   public int hashCode() {

       return (pointSize * 37 + effects.hashCode() * 13) * fontFace.hashCode();

}

   // Getters for the font data, but no setters. FontData is immutable.

}

C#

using System.Collections; using System.Collections.Generic; using System; class GraphicChar {

   char c;

   string fontFace;

public GraphicChar(char c, string fontFace) { this.c = c; this.fontFace = fontFace; }

   public static void printAtPosition(GraphicChar c, int x, int y)   {

Console.WriteLine("Printing '{0}' in '{1}' at position {2}:{3}.", c.c, c.fontFace, x, y); } } class GraphicCharFactory {

   Hashtable pool = new Hashtable(); // the Flyweights

public int getNum() { return pool.Count; }

   public GraphicChar get(char c, string fontFace) {

       GraphicChar gc;

       string key = c.ToString() + fontFace;

       gc = pool[key] as GraphicChar;

       if (gc == null) {

           gc = new GraphicChar(c, fontFace);

           pool.Add(key, gc);

}

       return gc;

} } class FlyWeightExample {

   public static void Main(string[] args) {

       GraphicCharFactory cf = new GraphicCharFactory();

       // Compose the text by storing the characters as objects.

       List text = new List();

       text.Add(cf.get('H', "Arial"));    // 'H' and "Arial" are called intrinsic information

       text.Add(cf.get('e', "Arial"));    // because it is stored in the object itself.

       text.Add(cf.get('l', "Arial"));

       text.Add(cf.get('l', "Arial"));

       text.Add(cf.get('o', "Times"));

       // See how the Flyweight approach is beginning to save space:

Console.WriteLine("CharFactory created only {0} objects for {1} characters.", cf.getNum(), text.Count);

       int x=0, y=0;

       foreach (GraphicChar c in text) {             // Passing position as extrinsic information to the objects,

           GraphicChar.printAtPosition(c, x++, y);   // as a top-left 'A' is not different from a top-right one.

} } }

External links

• Flyweight in UML and in LePUS3 (a formal modelling language)
• Article " Make your apps fly - Implement Flyweight to improve performance" by David Geary
• Article " Enhancing Web Application Performance with Caching" by Neal Ford
• Article " The Flyweight Pattern" by Alberto Bar-Noy
• Sample Chapter " C# Design Patterns: The Flyweight Pattern" by James W. Cooper
• Section " Flyweight Text Entry Fields" from the RIDES Reference Manual by Allen Munro and Quentin A. Pizzini
• Description from Portland's Pattern Repository
• Overview
• Sourdough Design
• Structural Patterns - Flyweight Pattern
• Class::Flyweight - implement the flyweight pattern in OO perl
• Boost.Flyweight - A generic C++ implemention