Tagged articles
delayed queue
38 articles · Page 1 of 1
This article details a production-ready dual-insurance pattern for e-commerce order timeout cancellation, combining RabbitMQ delayed message queues for real-time processing with scheduled database scans as a fallback, including Spring Boot implementation code, idempotent cancellation logic, and distributed deployment considerations.
IdempotencyMessage QueueRabbitMQ
0 likes · 16 min read

This article outlines nine practical Redis scenarios—including hot‑data caching, distributed locks with Redisson, Bloom filters for cache‑penetration protection, delayed queues using ZSet, token‑bucket rate limiting, bitmap boolean statistics, UV deduplication via Set/HyperLogLog/Bitmap, geospatial indexing, and lightweight Stream queues—explaining their motivations, implementation steps, and trade‑offs.
BitmapBloom FilterCaching
0 likes · 7 min read

This article explains three practical ways to automatically cancel orders that remain unpaid for 30 minutes in a Spring Boot application, covering a scheduled task, a RabbitMQ delayed queue, and Redis key‑expiration events, with complete code examples and configuration steps.
RedisSpring Bootdelayed queue
0 likes · 8 min read

This guide explains common use cases for delayed tasks, describes the two RabbitMQ delay‑queue methods (TTL + dead‑letter exchange and the rabbitmq‑delayed‑message‑exchange plugin), and provides step‑by‑step PHP code for configuring dead‑letter exchanges, queues, and timed message processing.
RabbitMQTTLdead-letter
0 likes · 10 min read

This article examines eleven practical techniques—from passive checks and scheduled jobs to advanced message‑queue and Redis solutions—for automatically closing expired e‑commerce orders, comparing their advantages, limitations, and ideal deployment scenarios.
Backenddelayed queueorder timeout
0 likes · 17 min read

This article explains why traditional polling fails for large‑scale delayed tasks, compares built‑in Java, RocketMQ, and RabbitMQ delay queues, and provides a detailed Redis‑based design with architecture diagrams, message structures, and a 2.0 version that uses real‑time locking for low‑latency delivery.
JavaRedisdelayed queue
0 likes · 8 min read

This article explains what delayed queues are, details two RabbitMQ implementations using TTL with dead‑letter exchanges and the rabbitmq‑delayed‑message‑exchange plugin, provides full Java configuration and producer/consumer code examples, and outlines common use‑cases such as order timeout and refund processing.
Dead Letter QueueJavaRabbitMQ
0 likes · 13 min read

This article compares six practical backend approaches—JDK DelayQueue, RocketMQ delayed messages, Redis expiration, Redis Zset, a dedicated task center, and passive closure—to automatically close unpaid e‑commerce orders after a configurable timeout, outlining their advantages, drawbacks, and suitable scenarios.
RedisRocketMQTask Scheduling
0 likes · 8 min read

This article explains the concept of delayed queues, compares them with scheduled tasks, outlines common business scenarios, and provides a complete Redis implementation using Sorted Sets, Lua scripts, and PHP code, including producer and consumer examples and performance considerations.
BackendMessage QueuePHP
0 likes · 17 min read

This guide explains how to implement delayed and priority queues in RabbitMQ 3.8 using Spring Boot 2.6, covering dead‑letter exchange configuration, message expiration, priority settings, code examples for sending and consuming messages, and practical considerations such as priority limits and ordering behavior.
JavaMessage QueueRabbitMQ
0 likes · 8 min read

This tutorial explains how to create delayed and priority queues in RabbitMQ using Spring Boot, covering dead‑letter queue configuration, TTL settings, priority parameters, and provides complete Java code examples for sending and consuming prioritized messages.
JavaMessage QueueRabbitMQ
0 likes · 6 min read

This article presents a comprehensive design and implementation of a serverless delayed message queue on AWS, evaluating various solutions such as RabbitMQ, ActiveMQ, RocketMQ, Redis, and ultimately proposing a hybrid Kafka‑SQS‑DynamoDB architecture with performance optimizations and operational insights.
AWSDynamoDBKafka
0 likes · 16 min read

This article compares two Redis‑based delayed‑queue approaches—listening to key‑space expiration events and using Redisson’s built‑in delayed queue—detailing their principles, Spring Boot demos, pitfalls, and why Redisson offers a more reliable solution for distributed applications.
Keyspace NotificationsRedisRedisson
0 likes · 18 min read

This article demonstrates how to use RabbitMQ's delayed‑queue plugin together with Spring Boot to create a lazy exchange, configure a durable queue, send messages with a specified delay, and consume them, providing complete Java code examples and explaining why this approach outperforms traditional Redis, database polling, or JVM DelayQueue solutions.
Message QueueRabbitMQSpring Boot
0 likes · 9 min read

This article explains why delayed queues are needed for scenarios like unpaid orders or auto‑generated comments, compares built‑in and third‑party solutions, and provides a detailed design and implementation guide for a Redis‑based delayed‑queue service, including version‑1.0 features, version‑2.0 optimizations, and multi‑node deployment.
JavaMessage QueueRabbitMQ
0 likes · 9 min read

This article explains the business scenarios that require delayed processing, compares several delay‑queue solutions such as Java's DelayQueue, RocketMQ and RabbitMQ, and then details a custom Redis‑backed delayed‑queue architecture (1.0 and 2.0 versions) with Zookeeper coordination, pull‑job and worker threads for high‑availability and real‑time message delivery.
JavaMessage QueueRedis
0 likes · 8 min read

The article explains the need for delayed processing in business scenarios, compares various delayed queue solutions such as Java DelayQueue, RocketMQ, and RabbitMQ, and details a Redis-based implementation with message storage, ZSET queues, pull jobs, workers, and Zookeeper coordination for high availability.
BackendRedisdelayed queue
0 likes · 6 min read

This article surveys various delayed‑queue solutions—including Kafka pause/resume, RocketMQ delay levels, Redis/Redisson zset timers, Youzan's custom design, Netty's HashedWheelTimer, and a Kafka‑based time‑wheel—analyzing their architectures, pros and cons, and offering practical implementation guidance.
RedisRocketMQdelayed queue
0 likes · 12 min read

This article explains how to replace inefficient traditional delay mechanisms with RabbitMQ's delayed‑queue plugin, showing step‑by‑step configuration, producer and consumer code in Spring Boot, and demonstrates successful delayed message delivery using real‑world examples such as auto‑confirm orders and ticket reservations.
Message QueueRabbitMQSpring Boot
0 likes · 8 min read

This article explains why traditional delayed‑message solutions like Redis expiration, database polling, or JVM DelayQueue are inefficient, and demonstrates how to use RabbitMQ's delayed‑queue plugin with Spring Boot to configure exchanges, send delayed messages, and consume them reliably.
Message QueueRabbitMQSpring Boot
0 likes · 7 min read

This article explains why traditional delay solutions like Redis expiration, database polling, or JVM DelayQueue are inefficient, then demonstrates step‑by‑step how to configure RabbitMQ’s delayed‑queue plugin, create exchanges, queues, and bindings in Spring Boot, and send and consume delayed messages with code examples.
BackendJavaMessage Queue
0 likes · 9 min read

This article explains why using scheduled tasks for closing timed‑out orders is problematic, demonstrates how to use RabbitMQ dead‑letter queues and the x‑delay‑message plugin to achieve accurate order timeout handling, and provides complete Spring Boot configuration and code examples with testing and limitations.
BackendMessage SchedulingRabbitMQ
0 likes · 13 min read

This article surveys various delayed queue implementations—including Kafka, RocketMQ, Redis (Redisson), and Netty’s HashedWheelTimer—examining their design principles, advantages, drawbacks, and integration strategies, and proposes a unified micro‑service architecture leveraging Kafka topics, Redis ZSETs, and thread‑pool optimizations for reliable message scheduling.
KafkaNettyRedis
0 likes · 15 min read

This article explains the business scenarios that require delayed processing, compares several existing delayed‑queue solutions, and details a Redis‑backed delayed‑queue design—including its data structures, message format, multi‑node deployment, and runtime workflow—providing practical guidance for building scalable backend systems.
JavaRedisbackend architecture
0 likes · 8 min read

This article surveys delayed‑queue implementations, comparing Kafka, RocketMQ, and Redis (Redisson) designs, outlining their architectures, pros and cons, integration details, timing‑wheel mechanisms, and practical considerations for building a reliable distributed delayed‑queue service.
Kafkadelayed queuedistributed systems
0 likes · 13 min read

This article explains how to implement scheduled tasks in a Spring Boot application using RabbitMQ delayed queues, detailing the use of dead‑letter exchanges, message TTL settings, queue configuration, and Java code examples for publishing and consuming delayed messages.
RabbitMQSpring Bootdead-letter-exchange
0 likes · 9 min read

To handle distributed transactions in micro‑service systems, the article compares 2PC, TCC, maximum‑effort notification and reliable messaging, then shows how Spring Boot can use RabbitMQ delayed queues—leveraging dead‑letter exchanges, TTL and routing—to achieve eventual consistency for order‑payment workflows.
2PCRabbitMQSpring Boot
0 likes · 11 min read

This article explains how to implement delayed message delivery in RabbitMQ using the official delayed‑queue plugin and Spring Boot, compares traditional approaches such as Redis expiration and database polling, and provides complete configuration and code examples for producers and consumers.
Message QueueRabbitMQSpring Boot
0 likes · 8 min read

This article explains why Redis can be slow when used for delayed processing, shows how to implement a delayed queue with Redis ZSET, compares its advantages, and reviews alternative solutions such as RabbitMQ, RocketMQ, Kafka, Netty, and Java's DelayQueue.
KafkaMessage QueueRabbitMQ
0 likes · 8 min read

This article explains how to implement delayed message delivery in RabbitMQ using the delayed‑message‑exchange plugin and Spring Boot, covering the shortcomings of traditional approaches, configuration of exchanges and queues, sending messages with delay headers, and a test demonstrating a 6‑second delayed receipt.
Message QueueRabbitMQSpring Boot
0 likes · 8 min read

This article explains why traditional approaches like Redis expiration, database polling, or JVM DelayQueue are inefficient for delayed messaging, and demonstrates how to use RabbitMQ's delayed‑message‑exchange plugin with Spring Boot to create, configure, send, and consume delayed messages, including full code examples and a test showing a 6‑second delay.
Message QueueRabbitMQSpring Boot
0 likes · 8 min read


JavaEdgeNov 15, 2020 · Backend Development
RabbitMQ lacks native delayed‑queue support, but by combining message TTL with a dead‑letter exchange you can create a 15‑minute delayed processing pipeline for order cancellation, and this article explains the configuration steps and consumer setup needed to achieve it.
BackendMessage QueueRabbitMQ
0 likes · 2 min read

This article explains how Redis can be used to implement delayed queues, compares its advantages with other solutions such as RabbitMQ, RocketMQ, Kafka, Netty and Java DelayQueue, and provides practical guidance on using sorted sets and timestamps for time‑based task scheduling.
KafkaMessage QueueRabbitMQ
0 likes · 8 min read

This article walks through nine practical Redis use cases—including basic KV caching, distributed locking, delayed queues, rate limiting, service discovery, bitmap storage, HyperLogLog counting, roaring bitmaps, and Bloom filters—explaining the underlying concepts, configuration tips, and code examples for robust backend development.
BitmapBloom FilterCaching
0 likes · 20 min read

This guide explains common use cases for delayed tasks, describes two RabbitMQ delayed‑queue implementations—including TTL with dead‑letter exchanges and the rabbitmq‑delayed‑message‑exchange plugin—provides detailed configuration steps, code examples in PHP, and demonstrates how to run and verify the solution.
Backenddead-letter-exchangedelayed queue
0 likes · 10 min read

This article explains common delayed‑queue scenarios, demonstrates how to implement a delay queue using Redis Zset with atomic Lua scripts, and shows how to deploy and use Beanstalkd—including Java client setup and sample producer/consumer code—while offering extensions and best‑practice tips.
BackendBeanstalkdJava
0 likes · 6 min read

This article explains how to use RabbitMQ to build Remote Procedure Call (RPC) mechanisms and delayed message queues, detailing the required exchanges, correlation IDs, callback queues, and providing practical Node.js code examples for both client and server sides.
BackendRabbitMQdelayed queue
0 likes · 4 min read


21CTOMar 24, 2016 · Backend Development
This article explains the design, architecture, and implementation details of a Java-based delayed queue, covering use cases, core components, message lifecycle, protocol, current topology, shortcomings, and future improvements for reliable backend processing.
Message Queuebackend architecturedelayed queue
0 likes · 10 min read
