 |
This article includes a list of references, related reading or external links, but its sources remain unclear because it lacks inline citations. Please improve this article by introducing more precise citations where appropriate. (May 2008) |
Flyweight is a software design pattern. A flyweight is an object that minimizes memory use by sharing as much data as possible with other similar objects; it is a way to use objects in large numbers when a simple repeated representation would use an unacceptable amount of memory. The term comes from the boxing weight class with the same name[citation needed]. 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 might be desirable to have, for each character in a document, a glyph object containing its font outline, font metrics, and other formatting data, but this 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 internally.
In other contexts the idea of sharing identical data structures is called hash consing.
Contents |
Examples
Java
The following programs illustrate the document example given above: the flyweights are called FontData in the Java 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.
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<FontData, WeakReference<FontData>> FLY_WEIGHT_DATA = new WeakHashMap<FontData, WeakReference<FontData>>(); private final int pointSize; private final String fontFace; private final Color color; private final Set<FontEffect> effects; private FontData(int pointSize, String fontFace, Color color, EnumSet<FontEffect> 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<FontEffect> 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 (!FLY_WEIGHT_DATA.containsKey(data)) { FLY_WEIGHT_DATA.put(data, new WeakReference<FontData> (data)); } // return the single immutable copy with the given values return FLY_WEIGHT_DATA.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. }
Python
import weakref class Card(object): card_pool = weakref.WeakValueDictionary() def __new__(cls, value, suit): obj = cls.card_pool.get(value + suit, None) if not obj: obj = object.__new__(cls) cls.card_pool[value + suit] = obj return obj def __init__(self, value, suit): self.value = value self.suit = suit c1 = Card(0, 1) c2 = Card(1, 0) print id(c1), id(c2)
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 (archive.org)" 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
|
|||||||||||
This entry is from Wikipedia, the leading user-contributed encyclopedia. It may not have been reviewed by professional editors (see full disclaimer)
