MULTI command to start in Redis - Deep Dive

Overview - MULTI command to start

What is it?

The MULTI command in Redis starts a transaction block. It tells Redis to queue up multiple commands and execute them all at once later. This helps group commands so they run together without interruption. The commands are only run when EXEC is called.

Why it matters

Without MULTI, commands run one by one immediately, which can cause problems if you want several commands to happen together safely. MULTI ensures all commands in a group run as a single unit, preventing partial updates and keeping data consistent. This is important for things like banking or inventory systems.

Where it fits

Before learning MULTI, you should understand basic Redis commands and how Redis works as a key-value store. After MULTI, you can learn about EXEC, DISCARD, and WATCH commands to manage transactions fully.

Mental Model

Core Idea

MULTI marks the start of a group of commands that Redis will run together later as one atomic transaction.

Think of it like...

Think of MULTI like putting several letters into an envelope before mailing them all at once. You prepare everything first, then send them together so they arrive together.

┌─────────────┐
│ MULTI (start)│
└─────┬───────┘
      │
┌─────▼───────┐
│ Commands queued │
│ (SET, INCR, etc)│
└─────┬───────┘
      │
┌─────▼───────┐
│ EXEC (run all)│
└─────────────┘

Build-Up - 7 Steps

1

Foundation

What is Redis and Commands

Concept: Redis stores data as keys and values and lets you run commands to read or change data.

Redis is like a fast dictionary where you can add, get, or change values using commands like SET and GET. Each command runs immediately and changes the data right away.

Result

You can store and retrieve data quickly with simple commands.

Understanding how Redis commands work individually sets the stage for grouping them with MULTI.

2

Foundation

Why Group Commands Together

Concept: Sometimes you want several commands to happen together so data stays correct and consistent.

Imagine you want to move money from one account to another. You need to subtract from one and add to another. If something interrupts between these commands, data breaks. Grouping commands solves this.

Result

You see the need for running commands as a single unit to avoid partial changes.

Knowing the problem MULTI solves helps you appreciate why transactions matter.

3

Intermediate

Starting a Transaction with MULTI

🤔Before reading on: do you think MULTI runs commands immediately or queues them? Commit to your answer.

Concept: MULTI tells Redis to stop running commands right away and queue them instead.

When you send MULTI, Redis replies OK and waits. The next commands you send are not executed but stored in a list. They only run when you send EXEC.

Result

Commands after MULTI are queued, not run, until EXEC.

Understanding that MULTI queues commands changes how you think about command execution timing.

4

Intermediate

Executing Queued Commands with EXEC

🤔Before reading on: do you think EXEC runs commands one by one or all at once atomically? Commit to your answer.

Concept: EXEC runs all queued commands together as one atomic operation.

After MULTI queues commands, EXEC tells Redis to run them all in order without interruption. If any command fails, others still run, but the whole block is treated as a single unit.

Result

All queued commands run together, ensuring data consistency.

Knowing EXEC runs commands atomically helps prevent partial updates in your data.

5

Intermediate

Cancelling a Transaction with DISCARD

Concept: You can cancel queued commands before running them using DISCARD.

If you decide not to run the queued commands, sending DISCARD clears the queue and ends the transaction. Redis replies OK and returns to normal command mode.

Result

Queued commands are removed and not executed.

Knowing how to cancel transactions safely prevents unwanted changes.

6

Advanced

Error Handling Inside Transactions

🤔Before reading on: do you think Redis stops all commands if one queued command is invalid? Commit to your answer.

Concept: Redis queues commands without checking errors until EXEC runs them all.

If a command is invalid, Redis still queues it. Only when EXEC runs does Redis report errors for specific commands but still runs others. This means partial failures can happen inside a transaction.

Result

Some commands may fail during EXEC, but others still run.

Understanding this prevents surprises when errors appear only after EXEC.

7

Expert

WATCH and Optimistic Locking with MULTI

🤔Before reading on: do you think MULTI alone prevents data changes by others during your transaction? Commit to your answer.

Concept: WATCH lets you monitor keys for changes to abort transactions if data changes unexpectedly.

Before MULTI, you can WATCH keys. If any watched key changes before EXEC, Redis aborts the transaction to avoid conflicts. This is optimistic locking to keep data safe in concurrent environments.

Result

Transactions abort if watched keys change, preventing inconsistent updates.

Knowing how WATCH works with MULTI helps build safe concurrent applications.

Under the Hood

When you send MULTI, Redis switches to a special mode where it queues commands in memory instead of running them. These commands are stored in a list. When EXEC arrives, Redis runs all commands sequentially in a single step without other commands interrupting. This atomic execution ensures no other client can run commands in between. If DISCARD is sent, the queue clears and Redis returns to normal mode.

Why designed this way?

Redis was designed for speed and simplicity. MULTI queues commands to avoid complex locking mechanisms. This design keeps transactions fast and lightweight. Alternatives like locking would slow Redis down and complicate its single-threaded model. The queue approach fits Redis's event loop and single-threaded architecture perfectly.

┌─────────────┐
│ Client sends│
│ MULTI      │
└─────┬───────┘
      │
┌─────▼───────┐
│ Redis queues │
│ commands in │
│ memory list │
└─────┬───────┘
      │
┌─────▼───────┐
│ Client sends│
│ EXEC        │
└─────┬───────┘
      │
┌─────▼───────┐
│ Redis runs  │
│ all commands│
│ atomically  │
└─────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does MULTI run commands immediately or queue them? Commit to your answer.

Common Belief: MULTI runs commands immediately but marks them as part of a transaction.

Reality: MULTI queues commands without running them until EXEC is called.

Why it matters: Thinking commands run immediately leads to confusion about when data changes happen and can cause bugs in transaction logic.

Quick: If one command in a MULTI block fails, does Redis cancel all commands? Commit to your answer.

Common Belief: If one command fails, Redis cancels the entire transaction.

Reality: Redis still runs all commands; errors are reported after EXEC but do not stop other commands.

Why it matters: Assuming full rollback can cause data inconsistency if you don't check for errors after EXEC.

Quick: Does MULTI prevent other clients from changing data during your transaction? Commit to your answer.

Common Belief: MULTI locks keys so no other client can change data until EXEC finishes.

Reality: MULTI alone does not lock keys; other clients can change data unless you use WATCH.

Why it matters: Believing MULTI locks data can lead to race conditions and unexpected overwrites.

Quick: Can you run commands outside MULTI after sending MULTI but before EXEC? Commit to your answer.

Common Belief: You can run normal commands anytime even after MULTI starts.

Reality: After MULTI, commands are queued and not executed until EXEC or DISCARD ends the transaction.

Why it matters: Trying to run commands outside the transaction causes confusion and errors.

Expert Zone

1

Redis transactions are not fully isolated; commands run atomically but intermediate states are visible to other clients.

2

Errors inside EXEC do not rollback previous commands; you must handle errors manually after EXEC.

3

WATCH uses optimistic locking, which is efficient but requires retry logic in client code for conflicts.

When NOT to use

MULTI is not suitable when you need full rollback on errors or strict isolation. In such cases, use external locking or databases with full ACID transactions like PostgreSQL.

Production Patterns

In production, MULTI is combined with WATCH for safe concurrency. Clients often retry transactions on WATCH failures. MULTI is used for atomic counters, inventory updates, and session management where speed and atomicity matter.

Connections

Database Transactions

MULTI is Redis's way to implement transactions similar to other databases.

Understanding traditional database transactions helps grasp why MULTI queues commands and uses EXEC to commit.

Optimistic Locking

WATCH with MULTI implements optimistic locking to handle concurrent changes.

Knowing optimistic locking from other systems clarifies how Redis avoids heavy locks while keeping data safe.

Event Loop Programming

Redis's single-threaded event loop design influences how MULTI queues commands.

Understanding event loops explains why Redis queues commands instead of locking, keeping performance high.

Common Pitfalls

#1 Expecting commands to run immediately after MULTI.

Wrong approach:

MULTI
SET key1 value1
GET key1

Correct approach:

MULTI
SET key1 value1
GET key1
EXEC

Root cause:

Misunderstanding that MULTI queues commands and requires EXEC to run them.

#2 Assuming all commands rollback if one fails inside EXEC.

Wrong approach:

MULTI
SET key1 value1
INVALIDCOMMAND
EXEC

Correct approach:

MULTI
SET key1 value1
INVALIDCOMMAND
EXEC
// Check EXEC result for errors and handle manually

Root cause:

Belief that Redis transactions have full rollback like traditional databases.

#3 Not using WATCH when concurrent changes matter.

Wrong approach:

MULTI
INCR counter
EXEC

Correct approach:

WATCH counter
MULTI
INCR counter
EXEC

Root cause:

Ignoring that MULTI alone does not prevent race conditions.

Key Takeaways

MULTI starts a transaction by queuing commands instead of running them immediately.

EXEC runs all queued commands atomically, ensuring they execute together without interruption.

Errors inside a transaction do not rollback previous commands; you must check EXEC results carefully.

WATCH combined with MULTI provides optimistic locking to handle concurrent data changes safely.

Understanding Redis's single-threaded design explains why MULTI queues commands rather than locking keys.