RabbitMQ死信延时队列阻塞问题

最新推荐文章于 2025-06-05 00:29:46 发布
原创 最新推荐文章于 2025-06-05 00:29:46 发布 · 2.4k 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java-rabbitmq #rabbitmq #java

本文介绍了如何避免RabbitMQ死信队列中消息阻塞，通过为不同过期时间创建独立队列并配置死信处理，确保不同类型超时消息的及时执行。针对实习管理系统中的24小时和48小时过期需求，设计了四个定制队列及一个死信队列的解决方案。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

RabbitMQ死信延时队列阻塞问题

SHTL 博客：https://www.shtlls.ltd

问题

  1. 死信队列这种处理方式会出现一个问题：

    ​ 由于是一个队列，遵循先进先出原则，且每次检查只会判断第一个消息是否过期，不会每一个都判断，所以会出现长时间过期的消息会阻塞短时间过期的消息的情况，也就无法实现同一队列中多种超时时间间隔延时执行。

    ​ 这种方式也仅适用于过期时间一致的队列。

解决方法
可以根据不同的过期时间，设置不同的消息队列。
这个也仅针对过期时间类型仅为几种的情况，若间隔时间每一个都不一样，且无规律，则无法通过rabbitmq的死信队列实现，需要使用其他的方式。

  1. (针对实际项目<实习生管理系统>解决方法)目前有两种时间类型，一种是24小时，一种是48小时

    ​ 所以需要创建四个不同的延时队列，分别对应 22小时(79200000毫秒)、24小时(86400000毫秒)、46小时(165600000毫秒)、48小时(172800000毫秒)。

    ​ 将不同时间的消息存入不同的消息队列，将四个消息队列的过期消息都转发到一个死信队列，消费者只需要监听该死信队列即可。

代码简述

  1. 依赖

    <!-- spring-boot-starter-amqp -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-amqp</artifactId>
	<version>2.6.1</version>
</dependency>

  2. RabbitMqTtlConfig.java

    package com.macro.mall.config;

import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class RabiitMqTtlConfig {

    @Autowired
    private RabbitTemplate rabbitTemplate;


    @Bean("interviewTtlExchange")
    public DirectExchange ttlExchange() {
        return new DirectExchange("interview-ttl-exchange");
    }

    // 创建死信队列交换机 -direct类型
    @Bean("interviewDeadLetterExchange")
    public DirectExchange deadLetterExchange() {
        return new DirectExchange("interview-dead-letter-exchange");
    }


     @Bean("interviewTtlQueue22")
    public Queue ttlQueue22() {
        //设置在这个队列上的私信的去处->
        Map<String, Object> args = new HashMap<>(2);
        args.put("x-dead-letter-exchange", "interview-dead-letter-exchange");
        args.put("x-dead-letter-routing-key", "interview.dead.letter");

        //过期时间由队列统一设置
        //注意不是 x-expires,x-expires为队列存活时间,
        // x-message-ttl为队列内的消息存活时间
        //注意更改队列/交换机设置需要删除原有的
        return new Queue("interview-ttl-queue-22", true, false, false, args);
    }

    @Bean("interviewTtlQueue24")
    public Queue ttlQueue24() {
        //设置在这个队列上的私信的去处->
        Map<String, Object> args = new HashMap<>(2);
        args.put("x-dead-letter-exchange", "interview-dead-letter-exchange");
        args.put("x-dead-letter-routing-key", "interview.dead.letter");
        //过期时间由队列统一设置
        //注意不是 x-expires,x-expires为队列存活时间,
        // x-message-ttl为队列内的消息存活时间
        //注意更改队列/交换机设置需要删除原有的
        return new Queue("interview-ttl-queue-24", true, false, false, args);
    }

    @Bean("interviewTtlQueue46")
    public Queue ttlQueue46() {
        //设置在这个队列上的私信的去处->
        Map<String, Object> args = new HashMap<>(2);
        args.put("x-dead-letter-exchange", "interview-dead-letter-exchange");
        args.put("x-dead-letter-routing-key", "interview.dead.letter");

        //过期时间由队列统一设置
        //注意不是 x-expires,x-expires为队列存活时间,
        // x-message-ttl为队列内的消息存活时间
        //注意更改队列/交换机设置需要删除原有的
        return new Queue("interview-ttl-queue-46", true, false, false, args);
    }

    @Bean("interviewTtlQueue48")
    public Queue ttlQueue48() {
        //设置在这个队列上的私信的去处->
        Map<String, Object> args = new HashMap<>(2);
        args.put("x-dead-letter-exchange", "interview-dead-letter-exchange");
        args.put("x-dead-letter-routing-key", "interview.dead.letter");

        //过期时间由队列统一设置
        //注意不是 x-expires,x-expires为队列存活时间,
        // x-message-ttl为队列内的消息存活时间
        //注意更改队列/交换机设置需要删除原有的
        return new Queue("interview-ttl-queue-48", true, false, false, args);
    }


    // 绑定交换机与消息队列
    @Bean
    @DependsOn({"interviewTtlExchange", "interviewTtlQueue22"})
    public Binding ttlBinding22(@Qualifier("interviewTtlQueue22") Queue interviewTtlQueue22, Exchange interviewTtlExchange) {
        return BindingBuilder.bind(interviewTtlQueue22).to(interviewTtlExchange).with("interview.ttl.22").noargs();
    }

    @Bean
    @DependsOn({"interviewTtlExchange", "interviewTtlQueue24"})
    public Binding ttlBinding24(@Qualifier("interviewTtlQueue24") Queue interviewTtlQueue24, Exchange interviewTtlExchange) {
        return BindingBuilder.bind(interviewTtlQueue24).to(interviewTtlExchange).with("interview.ttl.24").noargs();
    }

    @Bean
    @DependsOn({"interviewTtlExchange", "interviewTtlQueue46"})
    public Binding ttlBinding46(@Qualifier("interviewTtlQueue46") Queue interviewTtlQueue46, Exchange interviewTtlExchange) {
        return BindingBuilder.bind(interviewTtlQueue46).to(interviewTtlExchange).with("interview.ttl.46").noargs();
    }

    @Bean
    @DependsOn({"interviewTtlExchange", "interviewTtlQueue48"})
    public Binding ttlBinding48(@Qualifier("interviewTtlQueue48") Queue interviewTtlQueue48, Exchange interviewTtlExchange) {
        return BindingBuilder.bind(interviewTtlQueue48).to(interviewTtlExchange).with("interview.ttl.48").noargs();
    }

    /**
     * 给22小时后过期消息队列发送消息
     */
    public void send22(String msg) {
        rabbitTemplate.convertAndSend("interview-ttl-exchange", "interview.ttl.22", msg, message -> {
            // 设置过期时间，过期之后从interview-ttl-queue死信转到interview-dead-letter-queue
            // 22小时后过期
            message.getMessageProperties().setExpiration("79200000");
            return message;
        });
    }

    /**
     * 给24小时后过期消息队列发送消息
     */
    public void send24(String msg) {
        rabbitTemplate.convertAndSend("interview-ttl-exchange", "interview.ttl.24", msg, message -> {
            // 设置过期时间，过期之后从interview-ttl-queue死信转到interview-dead-letter-queue
            // 24小时后过期
            message.getMessageProperties().setExpiration("86400000");
            return message;
        });
    }

    /**
     * 给46小时后过期消息队列发送消息
     */
    public void send46(String msg) {
        System.err.println("46\t" + msg);
        rabbitTemplate.convertAndSend("interview-ttl-exchange", "interview.ttl.46", msg, message -> {
            // 设置过期时间，过期之后从interview-ttl-queue死信转到interview-dead-letter-queue
            // 46小时后过期  165600000
            message.getMessageProperties().setExpiration("165600000");
            return message;
        });
    }

    /**
     * 给48小时后过期消息队列发送消息
     */
    public void send48(String msg) {
        System.err.println("48\t" + msg);
        rabbitTemplate.convertAndSend("interview-ttl-exchange", "interview.ttl.48", msg, message -> {
            // 设置过期时间，过期之后从interview-ttl-queue死信转到interview-dead-letter-queue
            // 48小时后过期   172800000
            message.getMessageProperties().setExpiration("172800000");
            return message;
        });
    }

}

  3. RabbitMqSendUtils.java

    package com.macro.mall.utils;

import com.alibaba.fastjson.JSON;
import com.macro.mall.bo.InterviewSaveMqBO;
import com.macro.mall.common.enums.ExpireEnum;
import com.macro.mall.config.RabiitMqTtlConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class RabbitMqSendUtils {

    @Autowired
    private RabiitMqTtlConfig rabiitMqTtlConfig;

    /**
     * 初筛过期定时提醒
     * @param bo
     */
    public void primaryScreeningSend(InterviewSaveMqBO bo) {
        bo.setExpire(ExpireEnum.ABOUT_TO_EXPIRE.getNum());
        rabiitMqTtlConfig.send22(JSON.toJSONString(bo));    // 设置22小时，过期前2小时提醒
        bo.setExpire(ExpireEnum.EXPIRED.getNum());
        rabiitMqTtlConfig.send24(JSON.toJSONString(bo));    // 设置24小时，过期提醒
    }

    /**
     * 一面、二面过期定时提醒
     * @param bo
     */
    public void firstSecondInterviewSend(InterviewSaveMqBO bo) {
        bo.setExpire(ExpireEnum.BIGIN_TO_INTERVIEW.getNum());
        System.out.println(JSON.toJSONString(bo));
        bo.setExpire(ExpireEnum.ABOUT_TO_EXPIRE.getNum());
        rabiitMqTtlConfig.send46(JSON.toJSONString(bo));    // 设置46小时，过期前2小时提醒
        bo.setExpire(ExpireEnum.EXPIRED.getNum());
        rabiitMqTtlConfig.send48(JSON.toJSONString(bo));    // 设置48小时，过期提醒
    }
}

  4. DeadLetterListener.java

    package com.macro.mall.config;

import com.alibaba.fastjson.JSON;
import com.macro.mall.bo.InterviewSaveMqBO;
import com.macro.mall.common.enums.InterviewEnum;
import com.macro.mall.service.FirstInterviewService;
import com.macro.mall.service.PrimaryScreeningService;
import com.macro.mall.service.SecondInterviewService;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 监听RabbitMQ队列，处理定时邮件通知
 */
@Component
public class DeadLetterListener {

    @Autowired
    private PrimaryScreeningService primaryScreeningService;
    @Autowired
    private FirstInterviewService firstInterviewService;
    @Autowired
    private SecondInterviewService secondInterviewService;

    @RabbitHandler
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue("interview-dead-letter-queue"),
            exchange = @Exchange("interview-dead-letter-exchange"),
            key = "interview.dead.letter" ))
    public void onMessage(String msg) {
        InterviewSaveMqBO bo = JSON.parseObject(msg,InterviewSaveMqBO.class);
        // 以下可以对返回的消息进行处理了
        if (bo.getDesc().equals(InterviewEnum.PRIMARY_SCREENING.getDesc())) {
            primaryScreeningService.sendRemindMail(bo);
        } else if (bo.getDesc().equals(InterviewEnum.FIRST_INTERVIEW.getDesc())) {
            firstInterviewService.sendRemindMail(bo);
        } else if (bo.getDesc().equals(InterviewEnum.SECOND_INTERVIEW.getDesc())) {
            secondInterviewService.sendRemindMail(bo);
        }
    }

}
图例

  1. Exchanges

    image-20211224140450451

  2. Queues

    image-20211224140513487

().equals(InterviewEnum.SECOND_INTERVIEW.getDesc())) {
secondInterviewService.sendRemindMail(bo);
}
}

  }
  ```
图例

  1. Exchanges

    [外链图片转存中…(img-FB98151d-1658905164202)]

  2. Queues

    [外链图片转存中…(img-SDSa9FJD-1658905164204)]

如何使用RebbitMQ延迟交换机插件解决死信交换机队头阻塞问题
m0_63278070的博客
12-27 711
我们如果同时发两次带有过期时间的消息时，使用TTL就会有队头阻塞问题，比如说，第一个发送的消息过期以后(10s)，第二个消息不会被打印出来(5s)。2.这个交换机，不仅做路由转发，还做消息存储（这就是延迟交换机和其他交换机最本质的区别）1.首先，安装完插件后，我们在控制台可以看到这个地方多了一个选项。首先，在使用这个插件之前，我们先来了解一下什么叫队头阻塞？1.首先将插件保存到对应目录的数据券。3.执行下面命令，安装插件。4.执行下面命令，开启插件。二、DelayExchange工作原理。
RabbitMQ的死信队列和延时队列
DMaker1993的博客
12-26 3604
本文介绍并实战RabbitMQ的死信队列，以及通过RabbitMQ如何实现延时队列。
RabbitMq TTL 队列过期时间长的消息阻塞后面过期时间短的消息
prettyboy2ge的博客
12-07 1799
利用RabbitMq的TTL time-to-live 来实现延时消费。 延时时间设置到每条消息上的。而不是给队列的。 实现方式为消息存活时间为动态用户页面可配置的。 这就导致了一个问题： 先用一条消息的存活时间是1天。后面又进了一条消息存活时间是1小时。 结果一小时到了，发现这条消息并没有被转发到消费延时过期消息的队列。 原因是尽管ttl是设给每条消息的。但是本质上，所有延时消息都还在一个队列里，对它过期时间的检测也是从头部开始的。 它不会检测每一条消息是否过期。而是顺序检测。 如果.
MQ之队列阻塞怎么办
最新发布
m0_74299224的博客
06-05 307
3. 业务场景抽象出来之后 —— MQ用的是并行消费，生产者发送的时候根据业务属性随机分发到共有队列——于是笔者就很自然得想到了——我要提升消费能力——我要开更多的线程并发处理业务。5. 贴主得业务场景最后抽象之后 MQ消费之后要进行DB得落库操作——机制的你一定发现问题了——我测——DB压力太大怎么办——当然机架组会有措施滴，会给你限流得——但是这个不可行。——回到问题的根源——我们为什么堵了——线上分析是因为某些用户得量太大了！——So 当然是限制消费者啦。因此，八股要活学活用！
RabbitMQ消息队列阻塞处理
weixin_44770684的博客
07-29 7614
适当增加消费端资源限制 以及增加消费端实例数来提高消费端对消息队列的消费能力，我的环境该消息队列的消费端实例数原本是一个实例，最终通过将该消费端实例数量增加到3个实例，才解决了消息队列阻塞的问题。(由于我写文档截图的时候已经把堆积的消息问题处理了，所以看的消息数值是9，消息阻塞的时候该值实际上和收到的告警的通知告警的数值是一致的)异步处理和批量处理：如果消息队列的负载过高，可以考虑将一些耗时较长的操作改为异步处理，或者批量处理多条消息，以减少消息队列的阻塞。等，来优化消息的处理和队列的性能。
RabbitMQ 入门教程(PHP版) 延迟队列，延迟任务
weixin_30538029的博客
07-01 689
延迟任务应用场景 场景一：物联网系统经常会遇到向终端下发命令，如果命令一段时间没有应答，就需要设置成超时。 场景二：订单下单之后30分钟后，如果用户没有付钱，则系统自动取消订单。 场景三：过1分钟给新注册会员的用户，发送注册邮件等。 实现方案 定时任务轮询数据库，看是否有产生新任务，如果产生则消费任务 pcntl_alarm为进程设置一个闹钟信号 swoole...
RabbitMq死信队列以及其它问题
WatsonXh的博客
04-19 421
之前放在有道云笔记，现在分享出来 RabbitMq 自动签收，也就是自动ack，都是执行完方法再签收的，本身使用了AOP方式来自动签收ack。 所以手动签收如果放到最后，其实是一样的。 不管是自动签收，还是手动签收，在开启了次数重试之后，重试到application.yml里面写的配置的次数之后，就会进入DLQ，如果配了的话。 关于什么样的消息才会进DLQ，如果配了DLQ的话，RabbitMq是每个队列都可以配独立的DLQ的，所以DLQ能单独处理。 消息进DLQ的情况： 设置了超时时间的消息，
基于rabbitmq死信队列实现运行时秒级定时任务框架
qq_35284533的博客
09-22 577
源码： 朗月/基于rabbitmq的任意时长秒级定时任务框架 (gitee.com)https://gitee.com/beiding/delay-task 简述 当我们面对一些及时性比较高的场景时，比如，秒杀活动在活动开始前十分钟预热要下架相关商品，活动结束后又要将相关商品自动上架；再比如，租房系统房租到期需要做结算。我们第一个想到的解决方案是使用一个定时任务每个10分钟扫一次库。但当数据量较大时，对数据库而言这无疑是一场灾难，而且轮询的粒度为10分钟精度太差。 直接使用rabbitm...
延时队列实现实战：如何利用 RabbitMQ 实现延时队列，以满足特定延迟处理需求
pengyi123的博客
04-03 1406
实现延时队列，可以通过RabbitMQ的死信队列（Dead-letter queue）特性，“死信队列”是当消息过期，或者队列达到最大长度时，未消费的消息会被加入到死信队列。然后，我们可以对死信队列中的消息进行消费，完成类似“延时”的效果。当RabbitMQ检测到消费者（如一个TCP连接）异常断开，例如因为消费者主机崩溃或因为网络问题，它将关闭该消费者的连接，并将消费者未确认的任何消息重新放入队列。在RabbitMQ中，对消息的优先级的支持是通过队列来实现的。在声明队列的时候，可以通过。
高效延时队列的设计与实现
09-02
RabbitMQ实现延时队列的基本原理： RabbitMQ结合消息的TTL和死信路由特性，将过期消息转发到死信队列，由消费者监听死信队列并消费。 Redis实现延时队列的原理： 使用ZSet存储消息，key为消息ID，value为延迟时间加...
RabbitMQ自学之路（九）——RabbitMQ实现延时队列的两种方式
互联网叫兽
06-29 9354
一、什么是延时队列 延时队列顾名思义，即放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费。 二、延时队列应用于什么场景 场景一：在订单系统中，一个用户下单之后通常有30分钟的时间进行支付，如果30分钟之内没有支付成功，那么这个订单将进行一场处理。这是就可以使用延时队列将订单信息发送到延时队列。 场景二：用户希望通过手机远程遥控家里的智能设备在指定的时间进行工作。这时候就可以将...
rabbitmq 队列堵塞
pocetong的博客
11-24 1838
RabbitMQ使用不当导致的队列堵塞问题及解决之道      本接盘侠接手的一个服务使用RabbitMQ和其他服务进行消息传输。我们发现，有时候RabbitMQ中明明有元素，但是不会回调DefaultConsumer接口的handleDelivery函数，于是队列无法消化，队列越堵越长。通过jstack查看，发现rabbitmq消费者线程堵塞在soc
RabbitMQ延时队列
Hello World
01-23 2314
延时队列 1.1 什么是延时队列 在开发中，往往会遇到一些关于延时任务的需求。例如 生成订单30分钟未支付，则自动取消 生成订单60秒后,给用户发短信 滴滴打车订单完成后，如果用户一直不评价，48小时后会将自动评价为5星。 和定时任务区别 对上述的任务，我们给一个专业的名字来形容，那就是延时任务。那么这里就会产生一个问题，这个延时任务和定时任务的区别究竟在哪里呢？一共有如下几点区别 定时任务有明确的触发时间，延时任务没有 定时任务有执行周期，而延时任务在某事件触发后一段时间内执行，没有执行周期。（可
RabbitMQ使用不当导致的队列堵塞问题及解决办法
热门推荐
runyon的博客
10-14 3万+
本接盘侠接手的一个服务使用RabbitMQ和其他服务进行消息传输。接手后发现：有时候RabbitMQ中明明有元素，但是不会回调DefaultConsumer的handleDelivery函数，于是队列无法消化，越堵越长。通过jstack查看，发现rabbitmq消费者线程堵塞在socketinputstream的socketRead0函数。通过搜索，发现这篇文章：《Queue consumer
RabbitMq 死信消息的过期时间的不同 会导致消费延时
m0_37801313的博客
07-02 1864
业务需求是：消息7天过期。 概述：自测没问题发布了测试版本，为了测试方便将过期时间7天修改为10分钟。但是由于之前跑的测试数据中已经发送过过期时间为7天的消息，导致后续过期时间为10分钟的消息始终无法消费。 处理方式： #未消费的消息数量 # ./rabbitmqctl list_queues Listing queues queue-question-expire 0 queue-question-expire-dl 32 #手动消费消息 # ./rabbitmqctl purge_q
一口气说出 6种 延时队列的实现方法，面试官也得服
HollisChuang's Blog
05-14 962
一、延时队列的应用什么是延时队列？顾名思义：首先它要具有队列的特性，再给它附加一个延迟消费队列消息的功能，也就是说可以指定队列中的消息在哪个时间点被消费。延时队列在项目中的应用还是比较多...
RabbitMQ延迟队列（重要）
qq_46112274的博客
11-06 3538
RabbitMQ延迟队列
RabbitMq死信队列那些坑
zalan01408980的博客
11-10 476
我们有了死信交换机和路由key后，就像配置业务队列一样，配置死信队列，然后绑定在死信交换机上。确切的说，为每个业务队列分配一个独有的路由key，并对应的配置一个死信队列进行监听，一般会为每个重要的业务队列配置一个死信队列。其次，为业务队列配置死信交换机和路由key,最后为死信交换机配置死信队列。当然，我们不是定义一个公共的死信队列，然后死信消息就到自己跑到死新队列了。正确的做法是使用死信的业务队列配置一个死信交换机，这里同一个项目的死信交换机可以共用一个，为每个业务队列分配一个单独的路由key。
使用RabbitMQ实现延迟队列
m0_37268363的博客
08-20 528
场景: 在项目中 1.用户确认一个订单,若30分钟之类没有支付,则需要取消订单,若用定时任务去扫描订单表,第一,定时任务时间如何定义,有存在漏扫的风险,第二,订单表数据庞大,扫描表非常消耗性能,这时候该功能可以引入RabbitMQ延迟队列来做 2.某条活动通知在指定的一天推送给用户,可以用延迟队列   定义: 延迟队列即发送一条消息给目标队列,并非让目标队列立即接受到消息,而是让消息等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值