Flyweight pattern: Difference between revisions
Lazeroptyx (talk | contribs) m →External links: fix stale link into codeproject.com domain for the article by Alberto Bar-Noy |
SuperDuffMan (talk | contribs) added imports for Java example |
||
Line 13: | Line 13: | ||
<source lang="java"> |
<source lang="java"> |
||
import java.lang.ref.WeakReference; |
|||
import java.util.WeakHashMap; |
|||
import java.util.Collections; |
|||
import java.util.EnumSet; |
|||
import java.util.Set; |
|||
import java.awt.Color; |
|||
public enum FontEffect { |
public enum FontEffect { |
||
BOLD, ITALIC, SUPERSCRIPT, SUBSCRIPT, STRIKETHROUGH |
BOLD, ITALIC, SUPERSCRIPT, SUBSCRIPT, STRIKETHROUGH |
Revision as of 09:38, 16 August 2010
This article includes a list of references, related reading, or external links, but its sources remain unclear because it lacks inline citations. (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 eponymous boxing weight class. 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 is 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.
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.
import java.lang.ref.WeakReference;
import java.util.WeakHashMap;
import java.util.Collections;
import java.util.EnumSet;
import java.util.Set;
import java.awt.Color;
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);
// Retrieve previously created instance with the given values if it (still) exists
WeakReference<FontData> ref = FLY_WEIGHT_DATA.get(data);
FontData result = (ref != null) ? ref.get() : null;
// Store new font data instance if no matching instance exists
if (result == null) {
FLY_WEIGHT_DATA.put(data, new WeakReference<FontData> (data));
result = data;
}
// return the single immutable copy with the given values
return result;
}
@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.
}
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++ implementation
- A C# definition and example