Что такое очереди в Redis?

А, так вот ты как, Redis, блядь! Слушай, давай я тебе про очереди расскажу, а то ты тут, пизда, наверное думаешь, что это какая-то космическая хуйня. Ан нет, всё проще, чем кажется, ёпта!

Представь себе, что у тебя есть список, обычный такой, в памяти. И вот этот список — он у тебя либо очередь, либо стек, смотря как его ебашить. Всё гениальное просто, как хуй в проруби.

А нахуя Redis для этого?

• Скорость, блядь! Всё в оперативке, всё летает, как угорелое. Никаких этих ваших дисковых задержек, чистая магия.
• Атомарность, сука! Все операции — раз! — и готово. Никаких гонок, когда два процесса одновременно лезут в одну кучу. Всё чётко, как у швейцарских часов, блядь.
• Надёжность, ёпта! Можно настроить, чтобы он на диск всё скидывал. Перезагрузился — а твои очереди, пизда, на месте, как ни в чём не бывало.

Основные команды, без которых нихуя:

• RPUSH <ключ> <значение>: Толкаешь элемент в конец списка, справа. Как встать в очередь за водкой.
• LPUSH <ключ> <значение>: Толкаешь элемент в начало, слева. Как пролезть без очереди, мудак.
• RPOP <ключ>: Выдернул и удалил элемент с конца. Забрал последнюю бутылку с полки.
• LPOP <ключ>: Выдернул и удалил элемент с начала. Первый зашёл — первый вышел.
• BLPOP <ключ> [ключ ...] <таймаут>: Блокирующий поп. Сидишь и ждёшь, пока в очереди что-то появится, как охранник у проходной. Не появилось за время — пошёл нахуй.
• BRPOP <ключ> [ключ ...] <таймаут>: То же самое, но с другого конца.

Ну и примерчики, чтобы совсем пиздец стало понятно (Python, redis-py):

1. Очередь FIFO (Первый зашёл — первый вышел): Кидаем справа, забираем слева. Как в нормальной столовой, а не как в армии.

import redis

r = redis.Redis(decode_responses=True)
queue_name = "my_fifo_queue"

# Закидываем задачи
r.rpush(queue_name, "task1", "task2", "task3")
print(f"Очередь после добавления: {r.lrange(queue_name, 0, -1)}")

# Забираем по порядку
task1 = r.lpop(queue_name)
print(f"Извлечено: {task1}, Очередь: {r.lrange(queue_name, 0, -1)}") # task1
task2 = r.lpop(queue_name)
print(f"Извлечено: {task2}, Очередь: {r.lrange(queue_name, 0, -1)}") # task2

2. Стек LIFO (Последний зашёл — первый вышел): Кидаем слева, забираем тоже слева. Как стопка тарелок: которую последнюю поставил — ту первую и берёшь, ёбаный в рот!

import redis

r = redis.Redis(decode_responses=True)
stack_name = "my_lifo_stack"

# Собираем стопку
r.lpush(stack_name, "item1", "item2", "item3")
print(f"Стек после добавления: {r.lrange(stack_name, 0, -1)}")

# Разбираем стопку
item1 = r.lpop(stack_name)
print(f"Извлечено: {item1}, Стек: {r.lrange(stack_name, 0, -1)}") # item3
item2 = r.lpop(stack_name)
print(f"Извлечено: {item2}, Стек: {r.lrange(stack_name, 0, -1)}") # item2

3. Блокирующая очередь (BLPOP): Вот это, блядь, мощь! Один процесс сидит, ждёт, как дурак, пока в очереди что-то появится. А другой в это время подкидывает ему работу. Красота, в рот меня чих-пых!

# В одном терминале (потребитель, который ждёт):
# import redis
# r = redis.Redis(decode_responses=True)
# print("Ожидаю элемент... сижу, курю...")
# task = r.blpop("my_blocking_queue", timeout=10) # Ждёт, блядь, целых 10 секунд!
# if task: print(f"Получен элемент: {task[1]}") # Ура, работа есть!
# else: print("Таймаут, нихуя не пришло, иди нахуй")

# В другом терминале (производитель, который кидает):
# import redis
# r = redis.Redis(decode_responses=True)
# r.rpush("my_blocking_queue", "urgent_task") # На, получай, ебашь!

И где этот пиздец применяется? Да везде, сука! Это ж основа основ!

• Фоновая обработка задач: Отправил письмо, поставил задачу в очередь — и пошёл дальше пить кофе. Celery, RQ — они все на этом стоят.
• Обмен сообщениями между сервисами: Один микросервис крикнул в очередь, другой подхватил. Тихий, блядь, диалог получается.
• Всякие умные кэши: Например, когда нужно выкидывать старые данные по принципу «кто давно не трогал — тот и иди нахуй».
• Логи: Чтобы не писать каждый чих сразу на диск, а накидать в очередь, а потом уже пачкой сохранить.