How Redis achieves sub-millisecond latency - Visual Walkthrough

Concept Flow - How Redis achieves sub-millisecond latency

Client sends command

↓

Redis receives command

↓

Process command in memory

↓

Use single-threaded event loop

↓

Execute command quickly

↓

Send response back to client

↓

Client receives response

Redis processes commands in memory using a fast single-threaded event loop to respond quickly, minimizing delays.

Execution Sample

Redis

SET key1 value1
GET key1

Stores a value in memory and retrieves it immediately with minimal delay.

Execution Table

Step	Action	Internal Process	Latency Impact	Output
1	Client sends SET command	Command received by Redis server	Minimal network delay	None
2	Redis processes SET	Stores key1=value1 in memory	Very fast due to in-memory operation	OK
3	Client sends GET command	Command received by Redis server	Minimal network delay	None
4	Redis processes GET	Retrieves value1 from memory	Very fast due to in-memory operation	value1
5	Response sent to client	Data sent over network	Minimal network delay	value1

💡 Commands complete quickly because Redis uses in-memory storage and a single-threaded event loop minimizing processing overhead.

Variable Tracker

Variable	Start	After Step 2	After Step 4	Final
key1	undefined	value1 stored	value1 retrieved	value1
command_queue	empty	SET command processed	GET command processed	empty

Key Moments - 2 Insights

Why does Redis use a single-threaded event loop instead of multiple threads?

Using a single-threaded event loop avoids context switching and locking overhead, allowing Redis to process commands quickly and maintain sub-millisecond latency, as seen in steps 2 and 4 of the execution_table.

How does in-memory storage affect Redis latency?

Storing data in memory means Redis can read and write data instantly without disk delays, which is why steps 2 and 4 show very fast processing times.

Visual Quiz - 3 Questions

Look at the execution_table, what is the output after Redis processes the SET command?

A "value1"

B No output

C "OK"

D "ERROR"

💡 Hint

Check the Output column at Step 2 in the execution_table.

At which step does Redis retrieve the stored value from memory?

A Step 4

B Step 2

C Step 1

D Step 5

💡 Hint

Look at the Internal Process column for the GET command in the execution_table.

If Redis used disk storage instead of memory, how would the latency change in the execution_table?

A Latency would stay the same

B Latency would increase at steps 2 and 4

C Latency would decrease at steps 2 and 4

D Latency would increase only at step 5

💡 Hint

Consider the Latency Impact column for in-memory operations in the execution_table.

Concept Snapshot

Redis achieves sub-millisecond latency by:
- Using in-memory data storage for instant access
- Processing commands with a single-threaded event loop
- Minimizing context switching and locking overhead
- Handling commands quickly and sending responses immediately
- Avoiding disk I/O delays for fast performance

Full Transcript

Redis achieves sub-millisecond latency by processing commands entirely in memory using a single-threaded event loop. When a client sends a command like SET or GET, Redis receives it quickly, processes it in memory without disk access, and sends the response back immediately. This approach avoids delays from disk I/O and multi-threading overhead, enabling very fast response times. The execution table shows each step from receiving commands to sending responses, highlighting minimal latency at each stage. Key points include Redis's use of in-memory storage and single-threaded processing to keep latency low and performance high.