Implementing Precise Order Cancellation: Delayed Task Solutions and Their Pitfalls

Preface

In e‑commerce and payment scenarios, orders are often cancelled automatically after a short delay when users abandon payment, and the timing is precise within one second; this article explores how such accuracy is achieved.

General methods include:

Using message‑queue delayed delivery features of RocketMQ, RabbitMQ, Pulsar, etc.

Using Redisson's DelayedQueue.

Some widely spread solutions have fatal flaws and should not be used for delayed tasks:

Using Redis expiration listeners.

Using RabbitMQ dead‑letter queues.

Using non‑persistent time wheels.

Redis Expiration Listener

The Redis official manual states that expired events are generated when the Redis server actually deletes the key, not when the TTL theoretically reaches zero.

Redis automatic expiration works via a periodic offline scan that deletes some expired keys and a lazy check that deletes a key upon access; Redis does not guarantee immediate deletion or notification, and notifications can be delayed by minutes.

Keyspace notifications use a fire‑and‑forget strategy, unlike message queues that guarantee delivery; clients subscribed to events may miss all events that occur while they are disconnected.

This is a lower‑cost solution than scanning a database, but it should not be used for reliable delayed tasks.

RabbitMQ Dead Letter

Dead Letter is a RabbitMQ mechanism that turns a message into a dead letter when any of the following conditions is met:

The message is negatively acknowledged (e.g., channel.basicNack) with requeue set to false.

The message exceeds its configured TTL in the queue.

The queue length exceeds its maximum limit.

If a dead‑letter exchange is configured, dead letters are routed to the designated dead‑letter queue.

Creating a dead‑letter queue generally involves:

Creating an exchange to serve as the dead‑letter exchange.

Configuring x-dead-letter-exchange and x-dead-letter-routing-key on the business queue to point to the dead‑letter exchange.

Creating a queue bound to the dead‑letter exchange and listening to it.

The purpose of a dead‑letter queue is to store messages that were not consumed normally for troubleshooting and possible re‑delivery, but it does not guarantee delivery timing; messages may be delayed until they become dead letters.

RabbitMQ provides the official delayed‑message exchange plugin ( rabbitmq-delayed-message-exchange ) for reliable delayed messaging.

Using Redis expiration listeners or RabbitMQ dead‑letter queues for delayed tasks misuses middleware, leading to hidden reliability issues such as lack of consistency guarantees, lower throughput, and potential resource leaks.

Time Wheel

A time wheel is an excellent data structure for timed tasks, but most implementations are purely in‑memory without persistence; if the process crashes, all scheduled tasks disappear, so it should be used with great caution.

Redisson DelayQueue

Redisson DelayQueue is a Redis‑based delayed queue built on a sorted set (zset). Each element’s score is the delivery timestamp; the queue periodically scans with zrangebyscore for due messages and moves them to a ready list.

As long as Redis does not crash, the delay queue guarantees that messages are not lost; it can be a viable option when no better solution exists.

When the database is well‑indexed, scanning for unfinished orders is not as costly as expected; combining a delay queue with periodic database scans provides a compensation mechanism to avoid task loss if the middleware fails.

Conclusion

Prefer using RocketMQ, Pulsar, or other message queues that provide built‑in delayed delivery.

If a professional message queue is unavailable, consider Redisson DelayQueue or other Redis‑based solutions, but design compensation mechanisms for possible Redis failures.

If neither is feasible, a time wheel can be used, but ensure additional protection such as database scanning because time‑wheel restarts are more frequent than Redis restarts.

Never use Redis expiration listeners to implement delayed tasks.

Source: www.cnblogs.com/Finley/p/16395466.html