Structural Patterns  «Prev  Next»
Lesson 5Flyweight: motivation
ObjectiveExplore the Motivations of the Flyweight Pattern

Flyweight Pattern and Motivation

In the realm of software architecture, one of the paramount concerns is the efficient utilization of resources, particularly when dealing with a large number of almost similar objects that have significant memory footprints. It is in this context that the Flyweight Pattern emerges as not merely an option but a necessity for any architect aiming for scalable and efficient systems. This design pattern serves to optimize memory usage and performance by sharing and reusing object data, thereby accomplishing the dual objective of resource conservation and operational efficiency. The motivation behind employing the Flyweight Pattern can be articulated under several key tenets:

Memory Efficiency

In scenarios where a system is burdened with a multitude of similar objects, the memory overhead can become a considerable challenge. The Flyweight Pattern mitigates this by sharing common state among multiple objects instead of keeping the state for each object. Imagine, for instance, a text editor that needs to represent each character as an object. Instead of creating individual objects for each occurrence of characters, the Flyweight Pattern would allow you to create a single object for each unique character, thus dramatically reducing memory consumption.

Improved Performance

The benefits are not just confined to memory optimization; the pattern also offers performance advantages. By reducing the number of unique objects, instantiation overhead is lowered, accelerating the object creation process. This speed gain is invaluable in real-time applications and large-scale systems where performance is of the essence.


As systems grow in complexity and data volume, scalability becomes a non-negotiable feature. The Flyweight Pattern inherently supports scalability by minimizing resource usage. When dealing with an increasingly large set of objects, the pattern ensures that the system remains responsive and capable of handling additional load without a proportional increase in resource consumption.

Consistency and Maintainability

When objects share common states, maintaining and updating the system becomes inherently easier. Any change to the shared state is automatically reflected across all instances that use the shared flyweight object. This consistency ensures that system behavior remains uniform, thereby simplifying maintenance tasks and reducing the likelihood of bugs and inconsistencies.

Facilitation of Complex Operations

The Flyweight Pattern provides a framework to handle complex operations efficiently. By externalizing the state and behavior of objects, the pattern allows you to manipulate many objects at once based on shared states. This capability is essential for operations like batch processing and bulk data manipulation.
In conclusion, the Flyweight Pattern is an indispensable tool for software architects striving for optimized, scalable, and maintainable systems. Its strategic adoption can provide substantial gains in memory efficiency, computational performance, and system scalability. Moreover, its utility extends to enhancing maintainability and facilitating complex operations, marking it as an imperative choice for architects aiming for robust, resource-efficient solutions. The judicious implementation of the Flyweight Pattern is not just a best practice; it is a strategic enabler of high-quality software architecture.
Object-oriented systems have a reputation for being big and slow. To some extent, this is a result of early, not particularly well-optimized implementations. Smalltalk, C++, and Java were all extremely slow in their early incarnations and produced multimegabyte executables for even simple Hello World-like programs. More sophisticated runtime environments and compiler optimizations have gone a long way toward removing the performance overhead associated with objects. However, it is still the case that in practice, object-oriented programming does not always produce the fastest code possible. If the objects in question are immutable (that is, they never change after they are constructed), and there are a relatively small number of states that the objects can assume, it may be possible to radically reduce the total number of objects in the system by using only copies of a few preconstructed objects.
For example, a Character class for a word processor might have only 200 or so instances (the lower and uppercase letters, assorted punctuation marks, white space, digits, and a few others). A 20, 000-character document might simply contain a list of 20,000 pointers to the 200 individual objects rather than 20,000 separate objects. If the pointers are much smaller or much faster to work with than the objects themselves (as they often are in practice) the memory footprint of a document can be reduced by a factor of 100 or more with a corresponding increase in performance. The Flyweight pattern does exactly this.

Flyweight Pattern

The Flyweight pattern describes how to share objects to allow their use at fine granularities without prohibitive cost. Each object of the flyweight pattern is divided into two pieces:
  1. the state-dependent (extrinsic) part, and
  2. the state-independent (intrinsic) part.
Intrinsic state is stored in the Flyweight object. Extrinsic state is stored or computed by client objects, and passed to the Flyweight when its operations are invoked.

Flyweight UML Diagram
Figure 5-5: Flyweight Pattern Diagram consisting of 1) Client, 2) FlyweightFactory, 3) IFlyweight interface, 4)Flyweight class

The Flyweight pattern relies on being able to divide up the application’s state into four types.
  1. The intrinsicState resides in the Flyweight objects.
  2. The Flyweight class implements an IFlyweight interface, which specifies the operations upon which the rest of the system relies.
  3. The Client maintains the unSharedState as well as a dictionary of all the Flyweights, which it gets from a FlyweightFactory whose job it is to ensure that only one of each value is created.
  4. Finally, the extrinsicState does not appear in the system as such; it is meant to be computed at runtime for each instrinsicState instance, as required.

FlyweightFactory: Creates and manages unique Flyweight objects Flyweight: Stores intrinsic state that is shareable among all objects There are other design options.
For example, in Figure 5-5 the Flyweight is shown as computing the extrinsicState.
However, the Client could do the computation and pass the extrinsicState to the Flyweight as a parameter to the Operation. Also, we regard the unSharedState as a Dictionary of values related to the Flyweights.
However, the unSharedState could have a more complex structure, warranting its own class. In this case, it would stand alongside the Flyweight class and implement the IFlyweight interface.