Skip to main content
Redis Basics
CHAPTER 05 Intermediate

Redis Lists Tutorial | Building Queues with LPUSH & RPOP

Updated: May 16, 2026
15 min read

# CHAPTER 5

Redis Lists and Queue Systems

1. Introduction

If you are building an application that sends welcome emails to new users, you do not want your web server to freeze for 2 seconds while the email is sending. The user will think the website crashed. Instead, you need a Background Job Queue. You place the "Send Email" task into a fast queue, instantly tell the user "Welcome!", and let a separate background worker process the queue. Redis Lists are the industry standard for building these lightning-fast queue systems.

2. Learning Objectives

By the end of this chapter, you will be able to:
  • Understand the architecture of a Linked List.
  • Add items to the left (head) and right (tail) of a list.
  • Extract and remove items from a list.
  • Read data from a list without deleting it.
  • Architect a FIFO (First-In, First-Out) Task Queue.

3. LPUSH and RPUSH (Adding Data)

A Redis List is a chain of strings. You can push data into the Left side (Start) or the Right side (End).

Open your redis-cli:

bash
1 
LPUSH tasks "Task 1"

*(Redis returns 1, meaning there is 1 item in the list).*

bash
1 
LPUSH tasks "Task 2"

Because we used LPUSH (Left Push), "Task 2" was shoved into the absolute front of the line. The list now looks like this: [Task 2, Task 1].

If we want to add an item to the absolute back of the line, we use RPUSH (Right Push):

bash
1 
RPUSH tasks "Task 3"

The list now looks like this: [Task 2, Task 1, Task 3].

4. LRANGE (Reading Data)

To see what is inside the list, we use the LRANGE command. It asks for a start index and an end index.
bash
1 
LRANGE tasks 0 1

*(Returns the first two items: "Task 2" and "Task 1").*

The Magic Index: If you want to see the entire list, but you don't know how long it is, use -1 as the end index. -1 mathematically means "the very last item".

bash
1 
LRANGE tasks 0 -1

*(Returns all 3 items).*

5. LPOP and RPOP (Extracting Data)

In a proper Queue system, when a worker takes a task, the task must be *removed* from the list so nobody else does it twice. The POP commands read the data AND delete it simultaneously in one atomic operation.
bash
1 
LPOP tasks

*(Returns "Task 2", and deletes it from the list).*

bash
1 
RPOP tasks

*(Returns "Task 3", and deletes it from the list).*

6. Architecting a FIFO Queue

FIFO stands for "First-In, First-Out". It is exactly like a line at a grocery store. The first person in line is the first person served. To build this in Redis:
  1. 1. The Web Server (Producer): Uses LPUSH to put new emails into the left side of the queue.
  1. 2. The Background Worker (Consumer): Runs a continuous loop using RPOP to pull emails off the right side of the queue and send them.

This perfectly guarantees that older tasks are completed first!

7. Performance: Why Linked Lists?

Why doesn't Redis use standard Arrays? If you have an Array with 10 million items, and you want to add an item to the very front, the computer has to physically move 10 million items over by one slot in RAM. This is agonizingly slow. A Linked List uses C-pointers. To add an item to the front, it just changes one memory pointer. Therefore, LPUSH takes exactly the same amount of time (microseconds) whether the list has 1 item or 100 million items!

8. Mini Project: Recent Visitors Log

Let's build a system that strictly tracks only the 5 most recent visitors to a website.
  1. 1. User Alice visits: LPUSH recent_visitors "Alice"
  1. 2. User Bob visits: LPUSH recent_visitors "Bob"
  1. 3. User Charlie visits: LPUSH recent_visitors "Charlie"
  1. 4. User Dave visits: LPUSH recent_visitors "Dave"
  1. 5. User Eve visits: LPUSH recent_visitors "Eve"
  1. 6. User Frank visits: LPUSH recent_visitors "Frank"
The list now has 6 items. We only want 5. We use the LTRIM command to mathematically slice the list! LTRIM recent_visitors 0 4 (Keeps index 0 through 4, deletes the rest). The oldest visitor (Alice) is instantly deleted!

9. Common Mistakes

  • Using LINDEX for large lists: You can ask Redis for a specific item in the middle of a list using LINDEX mylist 500000. However, because it is a linked list, Redis has to start at the beginning and physically count 500,000 links to find the item. This is an O(N) operation and is extremely slow. Lists are designed for accessing the ends (Head/Tail), not the middle.

10. Best Practices

  • Blocking POP (BRPOP): If your background worker constantly runs RPOP on an empty list, it wastes CPU cycles asking "Is there a task? Is there a task?". Instead, use BRPOP tasks 0. This command "Blocks" (freezes) the worker until a task actually appears, saving massive amounts of CPU power.

11. Exercises

  1. 1. What command pushes data into the absolute front (head) of a Redis List?
  1. 2. What command retrieves all items in a list without deleting them?

12. Redis Challenges

You are building a chat application. You want to store the "Chat History" of a room in a Redis List. When a new message arrives, it should appear at the bottom of the chat screen. When users load the room, they should see the messages in chronological order (oldest at top, newest at bottom). Describe the LPUSH/RPUSH architecture required to achieve this. *(Answer: When a new message is sent, the server uses RPUSH to append it to the absolute end (right side) of the List. When a user loads the room, the server runs LRANGE room_chat 0 -1 to fetch the list from left-to-right, ensuring the chronological flow is perfectly preserved).*

13. MCQ Quiz with Answers

Question 1

When architecting a standard FIFO (First-In, First-Out) background job queue using a Redis List, what is the mathematically correct combination of commands for the Producer and Consumer?

Question 2

Why does a Redis List execute LPUSH in microseconds regardless of whether the list contains 10 items or 10 million items?

14. Interview Questions

  • Q: Explain the structural difference between a standard Array and a Redis Linked List. Detail the Big O performance implications of inserting data at the head (LPUSH) versus searching for data in the middle (LINDEX).
  • Q: Describe how you would utilize the BRPOP (Blocking Right Pop) command to optimize the CPU utilization of a background worker script processing a task queue.

15. FAQs

Q: Can I store JSON objects inside a List? A: Absolutely! A List just holds Strings. You can serialize a complex JSON object (e.g., {"email": "test@test.com", "template": "welcome"}) and LPUSH the entire JSON string into the queue for the worker to decode.

16. Summary

You are now capable of building asynchronous architecture. By leveraging the pointer-based speed of Linked Lists and the atomic extraction of the POP commands, you can build massive, high-throughput task queues that prevent web applications from freezing under heavy traffic.

17. Next Chapter Recommendation

Lists are perfect for queues, but terrible for uniqueness. If you need to track 1 million unique IP addresses without allowing duplicates, a List will fail. In Chapter 6: Redis Sets and Sorted Sets, we will explore mathematical collections that enforce absolute uniqueness.

Finish this Chapter

Save your progress on your learning path and prepare for coding interview challenges.

Previous Chapter Redis Strings Tutorial | SET, GET, INCR Commands
Next Chapter Redis Sets Tutorial | Building Real-Time Leaderboards

Discussion

Join the discussion

Log in or create a free account to participate.

Sort: ·

Explore More

📖 Related Tutorials 6

❓ Related Quizzes 6