Flyweight Design Pattern in PHP: Optimize Memory Usage

The Flyweight design pattern in PHP is a structural design pattern focused on memory optimization. It achieves this by sharing common object data rather than duplicating it across multiple instances. This pattern becomes especially useful in applications where you deal with a large number of similar objects, such as rendering thousands of UI elements or game characters.

Using the Flyweight design pattern in PHP helps to significantly reduce memory consumption, making your application more efficient. If your application is suffering from performance issues due to object duplication, this design pattern is your best friend.

Let’s dive into a bad example and then see how Flyweight turns things around.

Bad Example: No Shared State

class Tree {
    public function __construct(
        public string $type,
        public string $color,
        public string $texture
    ) {}

    public function render(int $x, int $y) {
        echo "Rendering {$this->type} tree at ({$x}, {$y})\n";
    }
}

$trees = [];
for ($i = 0; $i < 1000; $i++) {
    $trees[] = new Tree('Oak', 'Green', 'Rough');
}

Why it’s bad:

• Each Tree object holds identical data (type, color, texture).
• 1000 Tree objects consume more memory than necessary.
• No separation between intrinsic (shared) and extrinsic (unique) states.

Good Example: Flyweight Pattern Applied

class TreeType {
    public function __construct(
        public string $type,
        public string $color,
        public string $texture
    ) {}

    public function render(int $x, int $y) {
        echo "Rendering {$this->type} tree at ({$x}, {$y})\n";
    }
}

class TreeFactory {
    private static array $treeTypes = [];

    public static function getTreeType(string $type, string $color, string $texture): TreeType {
        $key = md5($type . $color . $texture);

        if (!isset(self::$treeTypes[$key])) {
            self::$treeTypes[$key] = new TreeType($type, $color, $texture);
        }

        return self::$treeTypes[$key];
    }
}

class Tree {
    public function __construct(
        private int $x,
        private int $y,
        private TreeType $type
    ) {}

    public function render() {
        $this->type->render($this->x, $this->y);
    }
}

$forest = [];
for ($i = 0; $i < 1000; $i++) {
    $treeType = TreeFactory::getTreeType('Oak', 'Green', 'Rough');
    $forest[] = new Tree(rand(0, 100), rand(0, 100), $treeType);
}

Why it’s good:

• TreeType is the Flyweight (shared data).
• Tree holds only position data (extrinsic).
• TreeFactory ensures reused objects.
• Saves memory by avoiding object duplication.

How the Flyweight Pattern in PHP Works

The Flyweight design pattern divides object data into two types:

• Intrinsic State: Shared among many objects (like tree type or texture).
• Extrinsic State: Varies per object and passed during runtime (like coordinates).

By storing the intrinsic state in a central cache, you prevent memory bloating. This technique is perfect for graphics-heavy or large data-driven PHP applications.

A classic example outside graphics would be document editors. Characters in text might share the same font style, so there’s no need to store font details for every character.

When to Use the Flyweight Design Pattern in PHP

Use the Flyweight design pattern in PHP when:

• You have a large number of similar objects.
• Memory usage is a concern.
• Most object data is duplicated across instances.

Avoid it when:

• The number of objects is small.
• The overhead of managing shared state outweighs benefits.

Final Thoughts

The Flyweight design pattern in PHP is a powerful yet underutilized solution for performance tuning. By introducing object sharing, it keeps memory usage minimal while maintaining functionality. This pattern is a great tool to have in your PHP architecture toolbox—especially for high-scale applications.

Interested in More Design Patterns?

Discover other powerful patterns like Factory, Strategy, and Observer in this full guide:

➡️ Design Patterns in PHP – The Complete Guide to All Types