Memcached

Overview

Memcached is a simple, high-performance, distributed in-memory cache. It stores opaque byte values under string keys with TTLs and evicts least recently used items when memory is full. It has no persistence, no replication, and no rich data types; clients spread keys across servers with consistent hashing.

That simplicity makes it very fast and easy to scale horizontally with multithreading on each node. Choose Memcached when you need a pure cache for large volumes of simple values; choose Redis when you need data structures, persistence, or replication.

When to use it

• Pure caching of database query results, rendered fragments, or objects.
• Very large cache clusters where simplicity matters.
• Multithreaded performance on large machines.
• Data you can always rebuild from the source of truth.

Where it shows up in interviews

Where it is used in real software

Key terms

Slab allocator

Memory divided into size classes to limit fragmentation.

LRU eviction

Remove least recently used items when full.

Client-side sharding

Clients hash keys to choose a server.

CAS

Check-and-set with a version token for optimistic updates.

How it works, step by step

1. 1
   Client hashes the key

   Consistent hashing picks one server.

2. 2
   get(key)

   Returns the value or a miss.

3. 3
   On miss, load from the DB

   Then set(key, value, ttl).

4. 4
   On write, delete the key

   Invalidate rather than update.

5. 5
   Server evicts under memory pressure

   LRU within slab classes.

Memcached vs Redis

Both are in-memory caches

For a plain cache either works; Redis is more common today because the extra features are often useful.

Implementation

1import Memcached from "memcached";2 3// Client hashes keys across servers4const cache = new Memcached(["cache-1:11211", "cache-2:11211", "cache-3:11211"]);5 6function getUser(id: string): Promise<User> {7  return new Promise((resolve, reject) => {8    cache.get(`user:${id}`, async (err, data) => {9      if (err) return reject(err);10      if (data) return resolve(JSON.parse(data));11      const user = await db.users.findById(id);12      cache.set(`user:${id}`, JSON.stringify(user), 300, () => resolve(user)); // 5 min TTL13    });14  });15}

Complexity and performance

Trade-offs

Variants and related techniques

Common mistakes

• Storing data that cannot be rebuilt.

  Fix: Memcached is not durable.

• Thundering herd on popular key expiry.

  Fix: Use leases or request coalescing and TTL jitter.

Interview questions

Practice problems