Chapter 6 checkpoint

Chapter 6 checkpoint: caching and invalidation

Every question from this chapter’s lessons. Your first answer to each is the one that counts; afterward you can practice again as often as you like. Passing needs 75% right on the first attempt.

0 of 17 answered0 right on the first attempt

Question 1 of 17

A cache answers in 2 ms and the database in 38 ms. A miss checks the cache and then queries the database. With a 95% hit ratio, what is the average latency per request?

Your answer

Answers within 1% count, in any unit you choose.

Question 2 of 17

A catalog has 10 million products, 20% of which receive most reads. Each cached item is 2 KB, and you allow 25% extra for overhead. How much RAM does the cache need for that working set, in GB?

Your answer

Answers within 5% count, in any unit you choose.

Question 3 of 17

The cache hit ratio falls from 99% to 95%. By what factor does the number of queries reaching the database grow?

Your answer×

Answers within 2% count.

Question 4 of 17

Match each caching tier to an example the lesson gives.

ClientCDNWeb serverApplication cacheDatabase

Question 5 of 17

With cache-aside, why should a write delete the cache entry instead of setting it to the new value?

Concurrent sets can land in the wrong order and leave a stale value; deletes are safe in any orderDeleting saves memorySetting would reset the TTLDeleting is faster than setting

Question 6 of 17

Match each cache update strategy to how it works.

Cache-asideWrite-throughWrite-behindRefresh-ahead

Question 7 of 17

What do you give up by choosing write-behind instead of write-through?

Nothing; it is strictly betterFast writesFast reads of just-written dataDurability: updates still in the cache are lost if it goes down

Question 8 of 17

A reader misses the cache, reads

V_1

from the database and stalls. Meanwhile a writer stores

V_2

and deletes the key. The reader then puts

V_1

into the cache. What prevents this “stale set”?

Leases: the delete invalidates the reader’s token, so its set is rejectedHaving the writer set the cache instead of deletingA longer TTLNothing can; it is unavoidable

Question 9 of 17

Millions of requests for product ids that do not exist, such as /product/-999999, miss the cache and reach the database. What stops them?

Switching the cache to LRU evictionMore database read replicasA Bloom filter of existing keys, or caching the “not found” result for a short timeLonger TTLs on existing entries

Question 10 of 17

How does XFetch (probabilistic early expiration) shrink cache stampedes?

It takes a lock so only one request recomputesIt guarantees stampedes cannot happenHot keys never expireEach request may recompute early, with a chance that grows as expiry nears

Question 11 of 17

Exactly one hour after a deploy, database load spikes sharply and then settles. All cache entries were filled at startup with a one-hour TTL. What prevents it next time?

Add a Bloom filterAdd random jitter to each TTLSwitch to LFU evictionUse a shorter TTL for everything

Question 12 of 17

A worker takes a Redis lock with SET lock:key token NX PX 5000 before recomputing a hot key. Why should the value be a random token?

So the lock expires after 5 secondsTo encrypt the cached valueSo a worker deletes the lock only if it still holds its own tokenSo the set succeeds only when the key is absent

Question 13 of 17

A nightly job reads every row of a large table once, through an LRU cache. Next morning the hit ratio is terrible. Why?

LRU evicts the oldest inserted items firstThe scan filled the cache with items used once, evicting the hot onesThe scan reset every TTLThe job leaked memory

Question 14 of 17

Match each eviction algorithm to what it evicts.

LRULFUFIFOARC

Question 15 of 17

A Redis cache holds keys without TTLs, and a small subset is read far more often than the rest. Which maxmemory-policy does Redis suggest as a good default?

volatile-lrunoevictionvolatile-ttlallkeys-lru

Question 16 of 17

A Redis instance uses volatile-lru, and none of its keys has a TTL. When memory fills, what happens?

Commands that add data start returning errors, while reads keep workingRedis crashesIt evicts keys at randomIt evicts the least recently used key of all

Question 17 of 17

A product service serves 50,000 reads a second. A deploy changes the cache keys, and the hit ratio falls from 99% to 90%. Which component saturates first?

Load balancerHandles up to 200,000 requests/s

App servers ×20Each handles 3,000 requests/s

RedisHandles up to 100,000 operations/sDatabaseHandles up to 2,000 queries/s