1.4. Pool

1.4.1. Purpose

Het ** objectpoolpatroon ** is een ontwerppatroon van software dat gebruikmaakt van een set geïnitialiseerde objecten die klaar voor gebruik worden gehouden - een “pool” - in plaats van ze op aanvraag toe te wijzen en te vernietigen. Een client van de pool zal een object uit de pool opvragen en bewerkingen uitvoeren op het geretourneerde object. Wanneer de klant klaar is, brengt hij het object, dat een specifiek type fabrieksobject is, terug naar de pool in plaats van het te vernietigen.

Objectpooling kan een aanzienlijke prestatieverbetering bieden in situaties waarin de kosten voor het initialiseren van een klasse-instantie hoog zijn, de snelheid waarmee een klasse wordt geïnstantieerd en het aantal instanties dat tegelijkertijd in gebruik is, laag is. Het gepoolde object wordt binnen een voorspelbare tijd verkregen wanneer het maken van de nieuwe objecten (vooral via het netwerk) variabele tijd kan duren.

Deze voordelen gelden echter meestal voor objecten die duur zijn in de tijd, zoals databaseverbindingen, socketverbindingen, threads en grote grafische objecten zoals lettertypen of bitmaps. In bepaalde situaties is eenvoudige pooling van objecten (die geen externe bronnen bevatten, maar alleen geheugen innemen) mogelijk niet efficiënt en kunnen de prestaties afnemen.

1.4.2. UML Diagram

1.4.3. Code

Je kan deze broncode terugvinden op GitHub

WorkerPool.php

<?php

declare(strict_types=1);

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): void
    {
        $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.php

<?php

declare(strict_types=1);

namespace DesignPatterns\Creational\Pool;

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

1.4.4. Теst

Tests/PoolTest.php

<?php

declare(strict_types=1);

namespace DesignPatterns\Creational\Pool\Tests;

use DesignPatterns\Creational\Pool\WorkerPool;
use PHPUnit\Framework\TestCase;

class PoolTest extends TestCase
{
    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);
    }
}