# Cachning

Queuety innehåller ett cachelager som minskar databasfrågor i ofta använda kodvägar, till exempel kontroller av om köer är pausade, räknare för hastighetsbegränsningar, uppslagningar av arbetsflödestillstånd och låsåtgärder. Cachen initieras automatiskt när du anropar `Queuety::init()`.

## Cachegränssnitt

Alla cache-bakändar implementerar `Queuety\Contracts\Cache`:

| Metod | Returnerar | Beskrivning |
|---|---|---|
| `get( string $key )` | `mixed` | Hämtar ett värde. Returnerar `null` om det inte hittas eller har löpt ut. |
| `set( string $key, mixed $value, int $ttl = 0 )` | `void` | Lagrar ett värde. TTL på 0 innebär att värdet inte löper ut. |
| `delete( string $key )` | `void` | Tar bort ett värde. |
| `has( string $key )` | `bool` | Kontrollerar om en nyckel finns och inte har löpt ut. |
| `add( string $key, mixed $value, int $ttl = 0 )` | `bool` | Anger ett värde bara om nyckeln inte redan finns (atomiskt). Returnerar `true` om värdet angavs. |
| `flush()` | `void` | Tar bort alla objekt från cachen. `ApcuCache::flush()` anropar `apcu_clear_cache()`, som rensar alla APCu-poster på servern, inte bara Queuetys. |

## Inbyggda bakändar

### MemoryCache (standard)

`Queuety\Cache\MemoryCache` är en arraybaserad cache per process. Objekt lagras i en PHP-array och går förlorade när processen avslutas. Detta är standardbakänden när APCu inte är tillgängligt.

Den kräver inga tillägg, fungerar bra för distributioner med en enda arbetare och håller varje arbetsprocess isolerad från de andra.

### ApcuCache

`Queuety\Cache\ApcuCache` använder APCu-tillägget för delat minne mellan alla PHP-processer på samma server. Alla nycklar får automatiskt prefixet `queuety:` för att undvika kollisioner med andra program.

Den här bakänden kräver tillägget `php-apcu`, delar cacheposter mellan arbetare på samma server och gör `add()` verkligt atomiskt via `apcu_add()`.

## Automatisk identifiering

`Queuety\Cache\CacheFactory` väljer automatiskt den bästa tillgängliga bakänden:

Om `apcu_store()` finns och `apcu_enabled()` returnerar `true` använder Queuety `ApcuCache`. Annars används `MemoryCache` som reserv. Detta sker inuti `Queuety::init()`, så standardbeteendet kräver ingen extra konfiguration.

## Vad som cachas

Cachelagret används internt av flera delsystem:

| Data | Syfte |
|---|---|
| Pausstatus för kö | Undviker en databasfråga vid varje varv i arbetsprocessens loop |
| Räknare för hastighetsbegränsningar | Följer körningsantal i minnet i stället för databasen |
| Arbetsflödestillstånd | Minskar antalet läsningar när arbetsflöden med flera steg förs vidare |
| Låsstatus | Snabbar upp kontroller av om lås finns för unika jobb och mutex-mellanprogramvara |

## Konfiguration av TTL

Standardvärdet för cache-TTL är 5 sekunder. Det gäller pausstatus för köer och räknare för hastighetsbegränsningar. Läsningar av arbetsflödesstatus och -tillstånd cachas i fasta 2 sekunder, vilket konstanten inte ändrar. Åsidosätt standardvärdet med konstanten `QUEUETY_CACHE_TTL` i din `wp-config.php`:

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

En lägre TTL innebär fler databasfrågor men färskare data. En högre TTL minskar databasbelastningen men innebär att data kan vara mer inaktuella. För de flesta distributioner är standardvärdet på 5 sekunder en bra avvägning.

## Anpassad cache-bakände

Om du vill använda en anpassad cache-bakände (Redis, Memcached eller något annat) implementerar du gränssnittet `Contracts\Cache` och anropar `Queuety::set_cache()` före `Queuety::init()`:

```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 );
```

Om `set_cache()` anropas före `init()` hoppas fabrikens automatiska identifiering över helt och din anpassade bakände används.

## Använda cachen

Hämta den aktiva cacheinstansen när som helst:

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

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

Detta returnerar den bakände som är aktiv för tillfället (MemoryCache, ApcuCache eller din egen implementering).