Design Patterns - Pool Pattern

Purpose

The purpose of the design pattern

The object pool pattern is a software creational design pattern that uses a set of initialised objects kept ready to use – a "pool" – rather than allocating and destroying them on demand. A client of the pool will request an object from the pool and perform operations on the returned object. When the client has finished, it returns the object, which is a specific type of factory object, to the pool rather than destroying it.

Object pooling can offer a significant performance boost in situations where the cost of initialising a class instance is high, the rate of instantiation of a class is high, and the number of instances in use at any one time is low. The pooled object is obtained in predictable time when creation of the new objects (especially over network) may take variable time.

However these benefits are mostly true for objects that are expensive with respect to time, such as database connections, socket connections, threads and large graphic objects like fonts or bitmaps. In certain situations, simple object pooling (that hold no external resources, but only occupy memory) may not be efficient and could decrease performance.

UML

UML design pattern diagram

Code

Code snippets

WorkerPool

The idea behind this is that once an instance of a class is required, we add them to an array of occupiedWorkers, once that class is finished with, we remove it from that array and assign to it a freeWorkers array.

If another instance of the class is required but we’ve got freeWorkers available, you’d use that instance rather than creating a new one.


namespace DesignPatterns\Creational\Pool;

use Countable;

class WorkerPool implements Countable
{
    /**
    * @var StringReverseWorker[]
    */
    private array $occupiedWorkers = [];

    /**
     * @var StringReverseWorker[]
     */
    private array $freeWorkers = [];

    public function get(): StringReverseWorker
    {
        if (count($this->freeWorkers) == 0) {
            $worker = new StringReverseWorker();
        } else {
            $worker = array_pop($this->freeWorkers);
        }

        $this->occupiedWorkers[spl_object_hash($worker)] = $worker;

        return $worker;
    }

    public function dispose(StringReverseWorker $worker)
    {
        $key = spl_object_hash($worker);

        if (isset($this->occupiedWorkers[$key])) {
            unset($this->occupiedWorkers[$key]);
            $this->freeWorkers[$key] = $worker;
        }
    }

    public function count(): int
    {
        return count($this->occupiedWorkers) + count($this->freeWorkers);
    }
}

StringReverseWorker

An example class instance used in the WorkerPool class.


namespace DesignPatterns\Creational\Pool;

use DateTime;

class StringReverseWorker
{
    public function __construct()
    {
    }

    public function run(string $text): string
    {
        return strrev($text);
    }
}

Tests

The only annoying aspect is that you’ll need to specifically dispose of an object once you’re finished using it. It also doesn’t make sense to use this on objects which aren’t extensive to create, it’s better suited for database connections or large graphic objects etc.


public function testCanGetNewInstancesWithGet()
{
    $pool = new WorkerPool();
    $worker1 = $pool->get();
    $worker2 = $pool->get();

    $this->assertCount(2, $pool);
    $this->assertNotSame($worker1, $worker2);
}

public function testCanGetSameInstanceTwiceWhenDisposingItFirst()
{
    $pool = new WorkerPool();
    $worker1 = $pool->get();
    $pool->dispose($worker1);
    $worker2 = $pool->get();

    $this->assertCount(1, $pool);
    $this->assertSame($worker1, $worker2);
}