# Gyorsítótárazás

A Queuety gyorsítótárréteget tartalmaz, amely csökkenti az adatbázis-lekérdezések számát az olyan gyakran használt útvonalakon, mint a várólisták szüneteltetésének ellenőrzése, a sebességkorlát-számlálók, a munkafolyamat-állapot lekérdezései és a zárolási műveletek. A gyorsítótár automatikusan inicializálódik a `Queuety::init()` meghívásakor.

## Gyorsítótár-interfész

Minden gyorsítótár-háttérmegvalósítás a `Queuety\Contracts\Cache` interfészt valósítja meg:

| Metódus | Visszatérési érték | Leírás |
|---|---|---|
| `get( string $key )` | `mixed` | Érték lekérése. `null` értéket ad vissza, ha nem található vagy lejárt. |
| `set( string $key, mixed $value, int $ttl = 0 )` | `void` | Érték tárolása. A 0 TTL korlátlan érvényességet jelent. |
| `delete( string $key )` | `void` | Érték eltávolítása. |
| `has( string $key )` | `bool` | Ellenőrzi, hogy a kulcs létezik-e és nem járt-e le. |
| `add( string $key, mixed $value, int $ttl = 0 )` | `bool` | Értéket állít be, csak ha a kulcs még nem létezik (atomikusan). `true` értéket ad vissza, ha az érték beállítása megtörtént. |
| `flush()` | `void` | A gyorsítótár összes elemének eltávolítása. A `ApcuCache::flush()` meghívja a `apcu_clear_cache()` elemet, amely a kiszolgáló összes APCu-bejegyzését törli, nem csak a Queuety bejegyzéseit. |

## Beépített háttérmegvalósítások

### MemoryCache (alapértelmezett)

A `Queuety\Cache\MemoryCache` folyamatalapú, tömbben tárolt gyorsítótár. Az elemek egy PHP tömbben tárolódnak, és a folyamat kilépésekor elvesznek. Ez az alapértelmezett háttértár, ha az APCu nem érhető el.

Nem igényel bővítményeket, jól működik egyetlen munkafolyamatot használó telepítéseknél, és minden munkafolyamatot elkülönít a többitől.

### ApcuCache

A `Queuety\Cache\ApcuCache` az APCu bővítményt használja a megosztott memóriához ugyanazon a kiszolgálón futó összes PHP folyamat között. Az ütközések elkerülése érdekében minden kulcs automatikusan a `queuety:` előtagot kapja.

Ehhez a háttértárhoz szükség van a `php-apcu` bővítményre; megosztja a gyorsítótár-bejegyzéseket az ugyanazon a kiszolgálón futó munkafolyamatok között, és a `apcu_add()` segítségével a `add()` valóban atomivá válik.

## Automatikus felismerés

A `Queuety\Cache\CacheFactory` automatikusan kiválasztja a legjobb elérhető háttértárat:

Ha létezik a `apcu_store()`, és a `apcu_enabled()` értéke `true`, akkor a Queuety a `ApcuCache`-t használja. Ellenkező esetben a `MemoryCache`-re vált vissza. Ez a `Queuety::init()`-ban történik, így az alapértelmezett működéshez nincs szükség további konfigurációra.

## Mi kerül a gyorsítótárba

A gyorsítótárréteget több alrendszer használja belsőleg:

| Adat | Cél |
|---|---|
| Várólista szüneteltetési állapota | Elkerüli az adatbázis-lekérdezést a munkafolyamat minden ciklusában |
| Sebességkorlátozási számlálók | A végrehajtások számát az adatbázis helyett memóriában követi |
| Munkafolyamat állapota | Csökkenti az olvasások számát a többlépéses munkafolyamat előrehaladása során |
| Zárolási állapot | Gyorsítja az egyedi feladatokhoz és a mutex middleware-hez tartozó zárolások meglétének ellenőrzését |

## TTL konfigurációja

Az alapértelmezett gyorsítótár-TTL 5 másodperc. A várólista szüneteltetési állapotára és a sebességkorlátozási számlálókra vonatkozik; a munkafolyamat állapotának olvasásai rögzített 2 másodpercig vannak gyorsítótárazva, ezt az állandó nem módosítja. Az alapértelmezett értéket a `QUEUETY_CACHE_TTL` állandóval írhatja felül a `wp-config.php` fájlban:

```php
define( 'QUEUETY_CACHE_TTL', 10 ); // 10 seconds
```

Az alacsonyabb TTL gyakoribb adatbázis-lekérdezéseket, de frissebb adatokat jelent. A magasabb TTL csökkenti az adatbázis terhelését, de elavultabb adatokat eredményez. A legtöbb telepítésnél az alapértelmezett 5 másodperc jó egyensúlyt biztosít.

## Egyéni gyorsítótár-háttértár

Egyéni gyorsítótár-háttértár (Redis, Memcached vagy más) használatához implementálja a `Contracts\Cache` interfészt, majd hívja meg a `Queuety::set_cache()` függvényt a `Queuety::init()` előtt:

```php
use Queuety\Contracts\Cache;
use Queuety\Queuety;

class RedisCache implements Cache {
    public function get( string $key ): mixed { /* ... */ }
    public function set( string $key, mixed $value, int $ttl = 0 ): void { /* ... */ }
    public function delete( string $key ): void { /* ... */ }
    public function has( string $key ): bool { /* ... */ }
    public function add( string $key, mixed $value, int $ttl = 0 ): bool { /* ... */ }
    public function flush(): void { /* ... */ }
}

// Set the cache before init() so all subsystems use it.
Queuety::set_cache( new RedisCache() );
Queuety::init( $connection );
```

Ha a `set_cache()` hívása a `init()` előtt történik, a gyár automatikus felismerése teljesen kimarad, és az egyéni háttértár lesz használatban.

## A gyorsítótár elérése

Az aktív gyorsítótárpéldány bármikor lekérhető:

```php
$cache = Queuety::cache();

$cache->set( 'my_key', 'my_value', 60 );
$value = $cache->get( 'my_key' );
```

Ez az éppen aktív háttértárat adja vissza (MemoryCache, ApcuCache vagy az Ön egyéni implementációja).