learnings
Programming
Caching
Common caching strategies

Common caching strategies

Some of the most common caching strategies include:

Strategy Pros Cons
Write-through • Data consistency between cache and storage
• No data loss on cache failure
• Simpler recovery		 • Higher write latency
• Increased write load on storage
• Less effective for write-heavy workloads
Write-around • Protects storage from write-intensive workloads
• Prevents cache pollution from write-once data
• Good for write-heavy, read-rarely patterns		 • Cache misses on first read after write
• Higher read latency for recently written data
• Additional complexity for consistency
Write-back • Lower write latency
• Reduced write operations to storage
• Better performance for write-heavy workloads		 • Risk of data loss on cache failure
• Inconsistency between cache and storage
• More complex recovery mechanisms needed
Cache-aside • Application has full control over caching logic
• Works well with existing applications
• Selective caching of data		 • Potential for stale data
• Additional application complexity
• Multiple clients need consistent implementation
Refresh-ahead • Reduced latency for predictable access patterns
• Fresh data for frequently accessed items
• Improved read performance		 • Wasted resources refreshing unused data
• Additional complexity for prediction logic
• Can increase system load during refresh cycles

Write-through caching

In write-through caching the data is simultaneously written to both the cache and the underlying storage system. When a write operation occurs, the system updates the cache first and immediately commits the same change to the primary storage. This approach aims to eliminating the risk of data loss that might occur with write-back caching, but it can introduce higher write latency compared to other caching strategies because each write operation must complete in both the cache and the primary storage before confirming completion to the client.

DatabaseCacheClientDatabaseCacheClientRead dataReturn data (if in cache)Read dataRequest data (if not in cache)Return dataReturn dataWrite dataWrite same data immediatelyAcknowledge writeConfirm write completed

Simplified code example:

package cache

import (
    "sync"
)

// Storage defines the interface for the underlying storage system
type Storage interface {
    Get(key string) (interface{}, bool)
    Set(key string, value interface{}) error
}

// WriteThruCache implements a write-through cache
type WriteThruCache struct {
    mu      sync.RWMutex
    cache   map[string]interface{}
    storage Storage
}

// NewWriteThruCache creates a new write-through cache with the given storage
func NewWriteThruCache(storage Storage) *WriteThruCache {
    return &WriteThruCache{
        cache:   make(map[string]interface{}),
        storage: storage,
    }
}

// Get retrieves a value from cache or underlying storage
func (c *WriteThruCache) Get(key string) (interface{}, bool) {
    // Try to get from cache first
    c.mu.RLock()
    value, found := c.cache[key]
    c.mu.RUnlock()

    if found {
        return value, true
    }

    // If not in cache, try to get from storage
    value, found = c.storage.Get(key)
    if found {
        // Store in cache for future reads
        c.mu.Lock()
        c.cache[key] = value
        c.mu.Unlock()
    }

    return value, found
}

// Set writes a value to both cache and storage (write-through)
func (c *WriteThruCache) Set(key string, value interface{}) error {
    // Write to storage first
    err := c.storage.Set(key, value)
    if err != nil {
        return err
    }

    // Then update cache
    c.mu.Lock()
    c.cache[key] = value
    c.mu.Unlock()

    return nil
}