Cache Invalidation — When and How Cache Clears

Automatic Cache Clearing

Manual Cache Clearing

# Clear specific type
php bin/magento cache:clean config

# Clear multiple types
php bin/magento cache:clean config layout

# Flush all cache
php bin/magento cache:flush

Cache Clearing Events

// When cache is cleared
$this->eventManager->dispatch('clean_cache_after');

// When cache is invalidated (tag-based)
$this->eventManager->dispatch('invalidate_cache', [
    'tags' => $tags
]);

How Tag Invalidation Works

1. Cache entry saved with tags ['product_123', 'products']
2. Product 123 updated
3. Invalidate tag 'product_123'
4. All entries with that tag are cleared
5. Other entries with 'products' tag remain

Implementation

// Save with tags
$cache->save($data, $key, ['product_123', 'products'], 3600);

// Invalidate by specific tag
$cache->clean('tags', ['product_123']);

// Invalidate by multiple tags
$cache->clean('tags', ['product_123', 'product_456']);

Tag Invalidation Flow

// Product save triggers invalidation
public function afterSave()
{
    parent::afterSave();
    $this->cache->clean('tags', [
        'catalog_product_' . $this->getId(),
        'product_list'
    ]);
}

Tag Hierarchy

// Specific tag
catalog_product_123       // Product 123 only

// General tag
catalog_products          // All products

// Page tag
page_product_123          // Product 123 page

Invalidation Scope

// Fine-grained (precise)
$cache->clean('tags', ['catalog_product_123']);

// Coarse-grained (broad)
$cache->clean('tags', ['catalog_products']);

// Hybrid (both)
$cache->clean('tags', ['catalog_product_123', 'catalog_products']);

What is Cache Stampede?

When a cache key expires and many requests try to regenerate the same cached data simultaneously.

Cache expires -> 100 concurrent requests -> All try to regenerate
-> Database overload -> Slow response times

Prevention Strategies

1. Lock File Pattern

public function getData(string $key): string
{
    $lockFile = BP . '/var/cache/lock_' . md5($key);
    
    if (file_exists($lockFile)) {
        // Wait for lock release
        while (file_exists($lockFile)) {
            usleep(10000); // 10ms
        }
        return $this->cache->load($key);
    }
    
    // Acquire lock
    file_put_contents($lockFile, 'locked');
    
    try {
        $data = $this->generateData();
        $this->cache->save($data, $key);
        return $data;
    } finally {
        unlink($lockFile);
    }
}

2. Early Expiration

// Expire cache before actual expiry
$ttl = 3600;
$earlyExpiration = $ttl * 0.9; // 90% of TTL

$cache->save($data, $key, $tags, $earlyExpiration);

3. Redis Locking

$lockKey = 'cache_lock_' . $key;
$acquired = $redis->set($lockKey, '1', ['NX', 'EX' => 5]);

if (!$acquired) {
    // Another process is regenerating
    return $cache->load($key);
}

try {
    $data = $this->regenerate();
    $cache->save($data, $key);
} finally {
    $redis->del($lockKey);
}

Stampede Monitoring

// Log regeneration attempts
if (!$this->cache->load($key)) {
    $this->logger->warning('Cache miss for: ' . $key);
}

Strategy 1: Immediate Invalidation

// Invalidate immediately on data change
public function afterSave()
{
    $this->cache->clean('tags', ['product_' . $this->getId()]);
}

Pros: Immediate consistency
Cons: May over-invalidate

Strategy 2: Deferred Invalidation

// Queue invalidation for batch processing
$this->publisher->publish('cache.invalidate', [
    'tags' => ['product_' . $this->getId()]
]);

Pros: Batch efficiency
Cons: Temporary inconsistency

Strategy 3: TTL-Based

// Let cache expire naturally
$cache->save($data, $key, [], 3600);
// No explicit invalidation needed

Pros: Simple
Cons: Delayed updates

Strategy 4: Event-Based

// Invalidate on specific events
$this->eventManager->dispatch('cache_invalidate', [
    'tags' => $tags,
    'type' => 'product_save'
]);

Decision Matrix