Tagged articles
delay queue
28 articles · Page 1 of 1
This article examines seven practical approaches—including Java DelayQueue, database polling, Redis queues, key‑expiration callbacks, RabbitMQ delayed messages, scheduled‑task frameworks, and event‑stream processing—to automatically cancel unpaid orders, comparing their scenarios, advantages, drawbacks, and implementation tips for scalable systems.
JavaRabbitMQbackend architecture
0 likes · 15 min read

This article examines why using Redis key‑space expiration notifications for delayed job execution is unreliable, compares common approaches such as message‑queue delayed delivery, RabbitMQ dead‑letter queues, time wheels, and Redisson DelayQueue, and provides practical recommendations for robust timeout handling in e‑commerce systems.
BackendRabbitMQRedis
0 likes · 7 min read

This article explains the concept, use cases, and common implementations of delay queues—including JDK's DelayQueue, RabbitMQ plugins, and Redis ZSet—followed by a detailed guide to installing, configuring, and using the open‑source lmstfy project, and concludes with promotional information for ChatGPT‑related services.
BackendGoMessage Queue
0 likes · 14 min read

This article explains the practical problems encountered when using Kafka directly, introduces SFMQ—a Kafka‑based HTTP proxy that unifies client access, simplifies upgrades, provides delay and transaction capabilities via Redis, and demonstrates how its architecture resolves producer, consumer, and operational challenges.
Message QueueTransactional Messagingarchitecture
0 likes · 18 min read

This article explains the concept, working principle, common use cases, and various implementations of delay queues—including JDK's DelayQueue, RabbitMQ plugins, Redis sorted sets, and the Go‑based lmstfy project—along with installation, configuration, and sample client code.
GoMessage QueueRabbitMQ
0 likes · 11 min read

This article introduces a Spring Boot starter that provides a ready‑to‑use Redis utility suite—including common tools, distributed locks, message queues, delay queues, pagination queries and web helpers—explains how to add the Maven dependency, configure modules via YAML, and details the internal auto‑configuration and bean implementations for MQ and delayed messaging.
JavaRedisSpring Boot
0 likes · 8 min read

The article evaluates common delayed‑task implementations—Redis expiration listeners, RabbitMQ dead‑letter queues, time wheels, and Redisson DelayQueue—explaining their drawbacks, proper use cases, and recommending reliable message‑queue solutions for e‑commerce order‑closing scenarios.
BackendMessage QueueRabbitMQ
0 likes · 7 min read

The article systematically compares eleven technical approaches for automatically closing expired e‑commerce orders, detailing each method’s implementation steps, trade‑offs, performance characteristics, and ideal deployment scenarios, and finally ranks them to guide practical selection.
Distributed SchedulingKafkaMessage Queue
0 likes · 19 min read


21CTOJun 27, 2023 · Backend Development
This article examines various order timeout handling techniques in e‑commerce, detailing JDK’s DelayQueue, RabbitMQ delayed messages, RocketMQ timer‑wheel, Redis expiration listeners, and distributed batch processing with SchedulerX, comparing their advantages, drawbacks, and suitability for different latency and scale requirements.
Distributed SchedulingRabbitMQRedis
0 likes · 14 min read

This article examines common delay‑processing scenarios such as payment timeouts and token refreshes, compares several implementation methods—including Java DelayQueue, MQ‑based delay queues, scheduled tasks, Redis ZSETs, and time wheels—highlights their advantages and drawbacks, and presents a concrete architecture and demo code for a robust, retry‑capable distributed delay component.
BackendRetrydelay queue
0 likes · 14 min read

This article explains how to build a precise, persistent delay queue using Redis data structures and Lua scripts, demonstrates a Go client library with code examples for sending, consuming, acknowledging, and retrying delayed messages, and discusses the design requirements such as durability, retry mechanisms, and timing accuracy.
GoLuaMessage Queue
0 likes · 13 min read

This article explains how to build a reliable delayed message queue using Redis, covering business scenarios, requirements such as persistence and retry, the design of Redis data structures, Lua scripts for atomic operations, and a Go implementation with example code for producing and consuming delayed tasks.
GoLuaMessage Queue
0 likes · 13 min read

This article explains how to build a reliable delayed message queue using Redis data structures and Go, covering business scenarios, design requirements, key Redis keys, Lua scripts for atomic operations, message lifecycle management, and provides complete source code for implementation.
GoLuadelay queue
0 likes · 14 min read

This article explains how to design and implement a precise, persistent, and retry‑capable delay queue using Redis ordered sets and Lua scripts, provides a complete Go library with usage examples, and discusses the underlying data structures, atomic operations, and garbage‑collection mechanisms.
GoMessage QueueRedis
0 likes · 11 min read

This article explains how to build a precise, persistent, and retry‑capable delayed task queue using Redis ordered sets, Lua scripts, and a Go client, addressing common e‑commerce scenarios like auto‑closing unpaid orders and sending activation messages.
GoLuaMessage Queue
0 likes · 13 min read

This article describes how the QMQ delay‑message service was refactored by separating business logic from storage, adopting Apache BookKeeper for high‑availability, zone‑aware disaster recovery, a configurable DNS resolver, a ZooKeeper‑based task coordinator, and a multi‑level sliding‑time‑bucket scheduler to achieve a stateless, elastic architecture.
BookKeeperElastic ArchitectureJava
0 likes · 13 min read

This article explains the design, implementation, and optimization of a Redis‑based delay queue using SpringBoot, Redisson, and distributed locks, covering use cases, architecture, data structures, job lifecycle, core code snippets, and future improvements for reliability and scalability.
Message QueueRedisRedisson
0 likes · 15 min read

This article explains Kafka's timing wheel algorithm, detailing its O(1) delay operation design, multi‑layer wheel structure, and how Kafka advances time using a DelayQueue, while comparing it with Netty and other open‑source projects.
BackendKafkadelay queue
0 likes · 11 min read

The article explains how Kafka implements delayed operations using a timing wheel with O(1) insertion and deletion, describes its parameters, multi‑level wheel design for large time spans, and the mechanism of advancing the wheel via DelayQueue and the ExpiredOperationReaper, contrasting it with Netty's approach.
AlgorithmBackenddelay queue
0 likes · 8 min read

This article explains the design and step‑by‑step implementation of a Redis delay queue using Java and Spring, covering the workflow, core components, task states, public APIs, container classes, timer handling, and testing procedures with complete code examples.
JavaRedisSpring
0 likes · 14 min read

To handle exploding daily traffic, the team rebuilt the messaging platform with a unified API, concurrent consumption, MongoDB storage, and a priority scheme that uses separate Kafka topics and adjustable pull ratios, while employing a state‑machine‑driven thread pool, multi‑tier delay mechanisms, and MongoDB/Redis‑based fatigue control, delivering fast, traceable, hierarchical urgent delivery with visual metrics and content safety.
Kafkadelay queuemessaging
0 likes · 5 min read

This article walks through the design, core components, task states, API endpoints, and full Java implementation of a Redis-powered delay queue using Spring Boot, complete with code samples, container structures, timer processing, and testing procedures.
JavaRedisSpring Boot
0 likes · 16 min read

Kafka handles many requests that require asynchronous processing or waiting for conditions by attaching a timeout parameter; if the condition isn’t met within the timeout, Kafka returns a timeout response, and it implements this efficiently using a hierarchical Timing Wheel data structure that offers O(1) insertion and fast expiration checks.
BackendKafkaScala
0 likes · 12 min read

The article explains how Kafka handles timeout‑based requests using a Timing Wheel data structure, detailing its design, parameters, operation principles, overflow handling, and providing Scala code examples that illustrate O(1) task insertion compared to traditional O(logN) delay queues.
KafkaScaladata structures
0 likes · 10 min read

This article reviews typical Kafka interview topics, explaining the implementation of delay queues with hierarchical time wheels, how idempotence is achieved via producer IDs, the meanings of ISR, OSR, AR, HW, LEO, LSO, strategies for guaranteeing message order, and practical solutions for handling duplicate consumption.
ISRIdempotencedelay queue
0 likes · 9 min read

This article explains how a distributed delayed‑execution component solves business scenarios that require timed actions, ensuring high availability and data consistency by leveraging Redis sorted sets and RabbitMQ dead‑letter queues, while providing a simple Java API and optional DB‑backed reliability.
Distributed SchedulingHigh AvailabilityJava
0 likes · 9 min read


JD TechSep 4, 2018 · Backend Development
This article describes the evolution, architectural design, and key implementation details of an order dispatch system for instant‑delivery services, covering problem analysis, delay‑task mechanisms such as database polling, DelayQueue and TimingWheel, and the final solution that combines Redis with a timing‑wheel scheduler and asynchronous processing.
Instant DeliveryKafkadelay queue
0 likes · 11 min read


ITPUBMar 21, 2016 · Backend Development
This article explores two practical approaches to implementing a delayed queue—using a sorted‑queue with JDK's DelayQueue logic and a Redis‑based solution with ordered sets and Spring Scheduled—to handle high‑throughput order processing while discussing their trade‑offs and implementation details.
ConcurrencyJavaScheduling
0 likes · 5 min read
