Achieve Ultimate Excellence

Flyweight Design Pattern - Optimizing Memory usage by sharing Mmmutable objects among Multiple Instances

5 min read

Introduction

Software design patterns are essential tools that help us create efficient, flexible, and maintainable code. One such pattern is the Flyweight design pattern, which focuses on optimizing memory usage by sharing common data among multiple objects. This blog post will explore the Flyweight design pattern, its principles, and a practical implementation in Java.

What is the Flyweight Design Pattern?

The Flyweight design pattern is a structural pattern that aims to reduce memory usage by sharing the intrinsic (immutable) state of objects among multiple instances. It is particularly useful when you have a large number of objects that share similar properties, and the state of these objects can be divided into intrinsic (shared) and extrinsic (unique) data.

Key Components

The Flyweight pattern consists of the following key components:

Flyweight: Represents the shared object that contains intrinsic state. This object is immutable and can be shared among multiple contexts.
ConcreteFlyweight: Implements the Flyweight interface and provides an implementation for the intrinsic state.
FlyweightFactory: Manages the creation and retrieval of Flyweight objects, ensuring they are shared and reused whenever possible.
Client: Maintains references to Flyweight objects and, if necessary, provides extrinsic state to the Flyweight objects during their operations.

Example: Implementing the Flyweight Pattern in Java

Let's illustrate the Flyweight pattern with a simple example. Suppose we want to create a drawing application where we have multiple shapes like circles and squares with different colors. Instead of creating a separate object for each shape-color combination, we'll use the Flyweight pattern to share the common color data among multiple shapes.

Step 1: Define the Flyweight Interface

public interface Shape {
    void draw();
}

Step 2: Create the ConcreteFlyweight Class

public class Circle implements Shape {
    private String color;

    public Circle(String color) {
        this.color = color;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a circle with color: " + color);
    }
}

Step 3: Implement the FlyweightFactory

import java.util.HashMap;
import java.util.Map;

public class ShapeFactory {
    private static final Map circleMap = new HashMap<>();

    public static Shape getCircle(String color) {
        Circle circle = (Circle) circleMap.get(color);

        if (circle == null) {
            circle = new Circle(color);
            circleMap.put(color, circle);
            System.out.println("Creating a new circle with color: " + color);
        }

        return circle;
    }
}

Step 4: Client Code

public class DrawingApp {
    private static final String[] colors = {"Red", "Blue", "Green", "Yellow"};

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            Shape circle = ShapeFactory.getCircle(getRandomColor());
            circle.draw();
        }
    }

    private static String getRandomColor() {
        return colors[(int) (Math.random() * colors.length)];
    }
}

Explanation

In the provided example, we first define the Shape interface representing the Flyweight. Then, we create the Circle class as a ConcreteFlyweight that implements the Shape interface. The intrinsic state in this case is the color property.

The ShapeFactory serves as the FlyweightFactory, responsible for managing the creation and retrieval of circle objects. It maintains a map to store already created circles and ensures that we reuse existing circles when possible.

Finally, the DrawingApp represents the Client code, where we request circles of different colors. Instead of creating a new circle for each request, the factory returns the existing circle with the desired color, promoting memory efficiency.

Conclusion

The Flyweight design pattern is a powerful tool for optimizing memory usage in applications that involve a large number of objects with shared properties. By identifying and isolating the intrinsic state, we can minimize memory overhead and improve the overall performance of our software.

By following the example and understanding the principles of the Flyweight pattern, developers can make informed decisions on when and how to apply this pattern to their projects, resulting in more efficient and maintainable code.

Article By,