Cachning

Visa som Markdown Redigera på GitHub Dokumentation på 2cc7b2b

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).