Atomic operations with Lua in Redis - Step-by-Step Execution

Concept Flow - Atomic operations with Lua

Start Lua script

↓

Execute commands inside script

↓

Commands run atomically

↓

Return result

↓

End script execution

Lua scripts in Redis run all commands inside them as one atomic operation, so no other commands run in between.

Execution Sample

Redis

redis.eval("return redis.call('incr', KEYS[1])", 1, 'counter')

This Lua script increments the 'counter' key atomically and returns the new value.

Execution Table

Step	Action	Command Executed	Key State Before	Key State After	Result
1	Start script	-	-	-	-
2	Call redis.call('incr', 'counter')	INCR counter	counter=5	counter=6	6
3	Return result	-	-	-	6
4	End script	-	-	-	-

💡 Script ends after returning the incremented value; all commands ran atomically.

Variable Tracker

Variable	Start	After Step 2	Final
counter	5	6	6

Key Moments - 2 Insights

Why does the counter not change between steps 2 and 3?

Because the Lua script runs atomically, no other commands can run between steps 2 and 3, so the counter stays at 6 as updated in step 2.

Can other Redis commands run while the Lua script is executing?

No, Redis blocks other commands during the Lua script execution to ensure atomicity, as shown by the uninterrupted steps in the execution_table.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'counter' after step 2?

A 6

B 5

C 7

D Undefined

💡 Hint

Check the 'Key State After' column in step 2 of the execution_table.

At which step does the Lua script return the incremented value?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'Result' column in the execution_table for the return action.

If another client tries to increment 'counter' during the script execution, what happens?

A It increments immediately

B It causes an error

C It waits until the script finishes

D It increments before the script

💡 Hint

Refer to the key_moments section about atomicity and command blocking.

Concept Snapshot

Lua scripts in Redis run atomically.
All commands inside a script execute without interruption.
Use redis.call() to run Redis commands inside Lua.
No other commands run until the script finishes.
This ensures consistent and safe updates.

Full Transcript

This visual execution trace shows how Redis runs Lua scripts atomically. The script starts and executes the INCR command on the 'counter' key. The counter value changes from 5 to 6 inside the script. Because the script runs atomically, no other commands can run between these steps. The script then returns the new counter value 6 and ends. This atomic behavior prevents race conditions and ensures data consistency in Redis.