In-memory caches and data stores

class LruCache {
  // An LRU cache with a time to live, like a Redis/Valkey key with EXPIRE, or a local in-process cache.
  items = new Map<string, [number | string, number]>();   // Map keeps insertion order: oldest first
  hits = 0; misses = 0; evictions = 0;
  constructor(private capacity: number, private ttl: number) {}

  get(key: string, now: number) {
    const item = this.items.get(key);
    if (item && item[1] > now) {
      this.items.delete(key); this.items.set(key, item);   // most recently used
      this.hits++;
      return item[0];
    }
    this.misses++;
    return undefined;
  }

  set(key: string, value: number | string, now: number) {
    this.items.delete(key);
    this.items.set(key, [value, now + this.ttl]);
    if (this.items.size > this.capacity) {
      this.items.delete(this.items.keys().next().value!);  // evict the least recently used
      this.evictions++;
    }
  }

  delete(key: string) { this.items.delete(key); }
}

const DB: Record<string, number> = { "price:42": 100 };

function read(cache: LruCache, key: string, now: number) {
  // Cache-aside: try the cache, fall back to the database, then fill the cache.
  let value = cache.get(key, now);
  if (value === undefined) { value = DB[key]; cache.set(key, value, now); }
  return value;
}

// Two app servers with their own local caches, against one shared cache (Redis, Valkey, Memorystore...).
const localA = new LruCache(3, 60), localB = new LruCache(3, 60), shared = new LruCache(3, 60);
for (const c of [localA, localB, shared]) read(c, "price:42", 0);

DB["price:42"] = 90;                             // server A updates the price at t=10 and invalidates its cache
localA.delete("price:42");
shared.delete("price:42");
console.log(`t=20 local caches: A sees ${read(localA, "price:42", 20)} | B sees ${read(localB, "price:42", 20)} (stale until its TTL)`);
console.log(`t=20 shared cache: A sees ${read(shared, "price:42", 20)} | B sees ${read(shared, "price:42", 20)}`);
console.log(`t=61 local cache B sees ${read(localB, "price:42", 61)} (TTL expired, refetched)`);

const lru = new LruCache(3, 1000);
for (const k of ["a", "b", "c", "a", "d", "b", "e", "a"]) if (lru.get(k, 0) === undefined) lru.set(k, k.toUpperCase(), 0);
console.log(`LRU, capacity 3: ${lru.hits} hits, ${lru.misses} misses, ${lru.evictions} evictions; kept ${[...lru.items.keys()].join(", ")}`);

import java.util.*;

public class Main {
    static class LruCache {
        // An LRU cache with a time to live, like a Redis/Valkey key with EXPIRE, or a local in-process cache.
        record Item(Object value, int expires) {}
        final LinkedHashMap<String, Item> items = new LinkedHashMap<>(16, 0.75f, true);   // access order: oldest first
        final int capacity, ttl;
        int hits, misses, evictions;
        LruCache(int capacity, int ttl) { this.capacity = capacity; this.ttl = ttl; }

        Object get(String key, int now) {
            Item item = items.get(key);                  // a get also marks it most recently used
            if (item != null && item.expires() > now) { hits++; return item.value(); }
            misses++;
            return null;
        }

        void set(String key, Object value, int now) {
            items.put(key, new Item(value, now + ttl));
            if (items.size() > capacity) {
                items.remove(items.keySet().iterator().next());   // evict the least recently used
                evictions++;
            }
        }

        void delete(String key) { items.remove(key); }
    }

    static final Map<String, Integer> DB = new HashMap<>(Map.of("price:42", 100));

    static Object read(LruCache cache, String key, int now) {
        // Cache-aside: try the cache, fall back to the database, then fill the cache.
        Object value = cache.get(key, now);
        if (value == null) { value = DB.get(key); cache.set(key, value, now); }
        return value;
    }

    public static void main(String[] args) {
        // Two app servers with their own local caches, against one shared cache (Redis, Valkey, Memorystore...).
        LruCache localA = new LruCache(3, 60), localB = new LruCache(3, 60), shared = new LruCache(3, 60);
        for (LruCache c : List.of(localA, localB, shared)) read(c, "price:42", 0);

        DB.put("price:42", 90);                          // server A updates the price at t=10 and invalidates its cache
        localA.delete("price:42");
        shared.delete("price:42");
        System.out.println("t=20 local caches: A sees " + read(localA, "price:42", 20) + " | B sees " + read(localB, "price:42", 20) + " (stale until its TTL)");
        System.out.println("t=20 shared cache: A sees " + read(shared, "price:42", 20) + " | B sees " + read(shared, "price:42", 20));
        System.out.println("t=61 local cache B sees " + read(localB, "price:42", 61) + " (TTL expired, refetched)");

        LruCache lru = new LruCache(3, 1000);
        for (String k : List.of("a", "b", "c", "a", "d", "b", "e", "a")) if (lru.get(k, 0) == null) lru.set(k, k.toUpperCase(), 0);
        System.out.println("LRU, capacity 3: " + lru.hits + " hits, " + lru.misses + " misses, " + lru.evictions + " evictions; kept " + String.join(", ", lru.items.keySet()));
    }
}