消息队列基础问题

雨点打透心脏的1/2处 2024-04-18 22:47 0阅读 0赞

### 文章目录 ###

*  1. 你们项目中用过消息队列吗
 *  2. 那你说一下你们在项目中是怎么用消息队列的
 *  3. 那你们为什么使用消息队列啊
 *  4. 那你说说消息队列都有什么优点和缺点？
 *   *  4.1 架构中引入MQ可能存在的问题
 *  5. kafka、rabbitmq、activemq、rocketmq都有什么区别？
 *  6. 那你们是怎么保证消息队列的高可用啊？
 *  7. 如何保证消息不被重复消费？如何保证消费的时候是幂等的？
 *  8. 如何保证消息的可靠性传输？要是消息丢失了怎么办？
 *  9. 如何保证消息的顺序性？
 *  10. 如何解决消息队列的延时以及过期失效问题？消息队列满了以后该怎么处理？有几百万消息持续积压几小时，说说怎么解决？
 *  11. 如果让你写一个消息队列，该如何进行架构设计？说一下你的思路
 *  mysql binlog 同步数据

# 1. 你们项目中用过消息队列吗 #

用过的。。。

# 2. 那你说一下你们在项目中是怎么用消息队列的 #

比如我们有一个订单系统，订单系统每次下一个新的订单的时候，就会发送一条消息到rabbitmq里面去，后台有个库存系统获取了消息然后更新库存。

# 3. 那你们为什么使用消息队列啊 #

（你的订单系统不发送消息到MQ，直接订单系统调用库存系统一个接口，咔嚓一下，直接就调用成功了，库存就更新了，那为啥还要用MQ ？）

最主要的三个目的：解耦、异步、削峰

1、 解耦：

*  不用MQ的系统耦合场景  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70]  
    如上图，在不使用消息队列的时候，如果A系统里产生了一些数据（或消息）需要发送给B、C、D系统，这时候又有一个E系统也需要得到这个消息，那么A系统就要修改代码也给E系统发送消息，后面如果又有其他系统要这个消息，或者现有的系统不要消息了，都要修改代码，就导致系统（或说服务）间的耦合性太高了。
    
    在这里A系统是和其他系统严重耦合的，除了场面说的每当有新的系统对消息的订阅产生需求时都要修改代码外，他还要考虑如果其他的系统挂了怎么办，例如C系统挂了怎么办，超时访问了怎么办，是不是还要做一个重试机制。
 *  使用了MQ之后的解耦场景  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 1]  
    图中少了对系统D的第4步说明：如果某个系统（系统D）不需要这条数据了就取消对MQ消息的消费即可。
    
    面试技巧：你需要去考虑一下你负责的系统中是否有类似的场景，就是一个系统或者一个模块，调用了多个系统或者模块，互相之间的调用很复杂，维护起来很麻烦。但是其实这个调用是不需要直接进行同步调用接口的，如果用MQ给他异步化解耦，也是可以的，你就需要去考虑在你的项目里，是不是可以运用这个MQ去进行系统的解耦。

2、异步

*  不用MQ的同步高延时请求场景  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 2]  
    这里少了第一步，1. 用户对系统A发起了一次请求，因为系统A要执行，BCD也要执行，执行总时间就等于全部系统执行时间相加，那用户等待的时间就可能过长，而互联网的请求时间要要求是`无感知`的，而当前场景时`高延时`的，不可接受。
 *  使用MQ进行异步化之后的接口性能优化  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 3]  
    如上图，在使用消息队列后，其实在系统A执行完毕，并推送消息后就直接返回执行结果给用户了，后面系统BCD的执行等于后台执行，多久都不会影响到用户了，解决了高延时的问题。

3、削峰

*  没有用MQ的时候高峰期系统被打死的场景  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 4]  
    说明：一般的MySQL，扛到每秒2000个请求就差不多了，如果每秒请求到5000的话，可能就直接把MySQL打死了（宕机）。
 *  使用MQ来进行削峰的场景  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 5]

# 4. 那你说说消息队列都有什么优点和缺点？ #

## 4.1 架构中引入MQ可能存在的问题 ##

*  可用性&复杂性&一致性  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 6]

缺点呢？显而易见的

**系统可用性降低：** 系统引入的外部依赖越多，越容易挂掉，本来你就是A系统调用BCD三个系统的接口就好了，人ABCD四个系统好好的，没啥问题，你偏加个MQ进来，万一MQ挂了咋整？MQ挂了，整套系统崩溃了，你不就完了么。

**系统复杂性提高：** 硬生生加个MQ进来，你怎么保证消息没有重复消费？怎么处理消息丢失的情况？怎么保证消息传递的顺序性？头大头大，问题一大堆，痛苦不已

**一致性问题：** A系统处理完了直接返回成功了，人都以为你这个请求就成功了；但是问题是，要是BCD三个系统那里，BD两个系统写库成功了，结果C系统写库失败了，咋整？你这数据就不一致了。

所以消息队列实际是一种非常复杂的架构，你引入它有很多好处，但是也得针对它带来的坏处做各种额外的技术方案和架构来规避掉，最好之后，你会发现，妈呀，系统复杂度提升了一个数量级，也许是复杂了10倍。但是关键时刻，用，还是得用的。。。

# 5. kafka、rabbitmq、activemq、rocketmq都有什么区别？ #

<table> 
 <thead> 
  <tr> 
   <th>特性</th> 
   <th>ActiveMQ</th> 
   <th>RabbitMQ</th> 
   <th>RocketMQ</th> 
   <th>Kafka</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>单机吞吐量</td> 
   <td>万级，吞吐量比RocketMQ和Kafka要低了一个数量级</td> 
   <td>万级，吞吐量比RocketMQ和Kafka要低了一个数量级</td> 
   <td>10万级，RocketMQ也是可以支撑高吞吐的一种MQ</td> 
   <td>10万级别，这是kafka最大的优点，就是吞吐量高。一般配合大数据类的系统来进行实时数据计算、日志采集等场景</td> 
  </tr> 
  <tr> 
   <td>topic数量对吞吐量的影响</td> 
   <td></td> 
   <td></td> 
   <td>topic可以达到几百，几千个的级别，吞吐量会有较小幅度的下降。这是RocketMQ的一大优势，在同等机器下，可以支撑大量的topic</td> 
   <td>topic从几十个到几百个的时候，吞吐量会大幅度下降。所以在同等机器下，kafka尽量保证topic数量不要过多。如果要支撑大规模topic，需要增加更多的机器资源</td> 
  </tr> 
  <tr> 
   <td>时效性</td> 
   <td>ms级</td> 
   <td>微秒级，这是rabbitmq的一大特点，延迟是最低的</td> 
   <td>ms级</td> 
   <td>延迟在ms级以内</td> 
  </tr> 
  <tr> 
   <td>可用性</td> 
   <td>高，基于主从架构实现高可用性</td> 
   <td>高，基于主从架构实现高可用性</td> 
   <td>非常高，分布式架构</td> 
   <td>非常高，kafka是分布式的，一个数据多个副本，少数机器宕机，不会丢失数据，不会导致不可用</td> 
  </tr> 
  <tr> 
   <td>消息可靠性</td> 
   <td>有较低的概率丢失数据</td> 
   <td></td> 
   <td>经过参数优化配置，可以做到0丢失</td> 
   <td>经过参数优化配置，消息可以做到0丢失</td> 
  </tr> 
  <tr> 
   <td>功能支持</td> 
   <td>MQ领域的功能极其完备</td> 
   <td>基于erlang开发，所以并发能力很强，性能极其好，延时很低</td> 
   <td>MQ功能较为完善，还是分布式的，扩展性好</td> 
   <td>功能较为简单，主要支持简单的MQ功能，在大数据领域的实时计算以及日志采集被大规模使用，是事实上的标准</td> 
  </tr> 
  <tr> 
   <td>优劣势总结</td> 
   <td>非常成熟，功能强大，在业内大量的公司以及项目中都有应用。偶尔会有较低概率丢失消息。而且现在社区以及国内应用都越来越少，官方社区现在对ActiveMQ 5.x维护越来越少，几个月才发布一个版本。而且确实主要是基于解耦和异步来用的，较少在大规模吞吐的场景中使用</td> 
   <td>erlang语言开发，性能极其好，延时很低；吞吐量到万级，MQ功能比较完备；而且开源提供的管理界面非常棒，用起来很好用；社区相对比较活跃，几乎每个月都发布几个版本分；在国内一些互联网公司近几年用rabbitmq也比较多一些；但是问题也是显而易见的，RabbitMQ确实吞吐量会低一些，这是因为他做的实现机制比较重。而且erlang开发，国内有几个公司有实力做erlang源码级别的研究和定制？如果说你没这个实力的话，确实偶尔会有一些问题，你很难去看懂源码，你公司对这个东西的掌控很弱，基本职能依赖于开源社区的快速维护和修复bug。而且rabbitmq集群动态扩展会很麻烦，不过这个我觉得还好。其实主要是erlang语言本身带来的问题。很难读源码，很难定制和掌控。</td> 
   <td>接口简单易用，而且毕竟在阿里大规模应用过，有阿里品牌保障；日处理消息上百亿之多，可以做到大规模吞吐，性能也非常好，分布式扩展也很方便，社区维护还可以，可靠性和可用性都是ok的，还可以支撑大规模的topic数量，支持复杂MQ业务场景；而且一个很大的优势在于，阿里出品都是java系的，我们可以自己阅读源码，定制自己公司的MQ，可以掌控；社区活跃度相对较为一般，不过也还可以，文档相对来说简单一些，然后接口这块不是按照标准JMS规范走的有些系统要迁移需要修改大量代码；还有就是阿里出台的技术，你得做好这个技术万一被抛弃，社区黄掉的风险，那如果你们公司有技术实力我觉得用RocketMQ挺好的</td> 
   <td>kafka的特点其实很明显，就是仅仅提供较少的核心功能，但是提供超高的吞吐量，ms级的延迟，极高的可用性以及可靠性，而且分布式可以任意扩展；同时kafka最好是支撑较少的topic数量即可，保证其超高吞吐量；而且kafka唯一的一点劣势是有可能消息重复消费，那么对数据准确性会造成极其轻微的影响，在大数据领域中以及日志采集中，这点轻微影响可以忽略；这个特性天然适合大数据实时计算以及日志收集</td> 
  </tr> 
 </tbody> 
</table>

综上所述，各种对比之后，我个人倾向于是：

一般的业务系统要引入MQ，最早大家都用ActiveMQ，但是现在确实大家用的不多了，没经过大规模吞吐量场景的验证，社区也不是很活跃，所以大家还是算了吧，我个人不推荐用这个了；

后来大家开始用RabbitMQ，但是确实erlang语言阻止了大量的java工程师去深入研究和掌控他，对公司而言，几乎处于不可控的状态，但是确实人是开源的，比较稳定的支持，活跃度也高；

不过现在确实越来越多的公司，会去用RocketMQ，确实很不错，但是我提醒一下自己想好社区万一突然黄掉的风险，对自己公司技术实力有绝对自信的，我推荐用RocketMQ，否则回去老老实实用RabbitMQ吧，人是活跃开源社区，绝对不会黄

所以中小型公司，技术实力较为一般，技术挑战不是特别高，用RabbitMQ是不错的选择；大型公司，基础架构研发实力较强，用RocketMQ是很好的选择

如果是大数据领域的实时计算、日志采集等场景，用Kafka是业内标准的，绝对没问题，社区活跃度很高，绝对不会黄，何况几乎是全世界这个领域的事实性规范

# 6. 那你们是怎么保证消息队列的高可用啊？ #

RabbitMQ是比较有代表性的，因为是`基于主从做高可用`的，另外我们的项目也是用RabbitMQ，所以这里主要以RabbitMQ为例。

rabbitmq有三种模式：单机模式、普通集群模式、镜像集群模式。

1）单机模式  
就是demo级别的，一般就是本地写写简单例子，生产环境不会用的。

2）普通集群模式  
其实就是增加了吞吐量，是没有解决高可用的。

意思就是在多台机器上启动多个rabbitmq实例，每个机器启动一个。但是你创建的queue，只会放在一个rabbitmq实例上，但是每个实例都同步queue的元数据。完了你消费的时候，实际上如果连接到了另外一个实例，那么那个shi’li会从queue所在实例上拉取数据过来。

这种方式确实很麻烦，也不怎么好，没做到所谓的分布式，就是个普通集群。因为这导致你要么消费者每次随机连接一个实例然后拉取数据，要么固定连接那个queue所在实例消费数据，前者有数据拉取的开销，后者导致单实例性能瓶颈。

而且如果那个queue的实例宕机了，会导致接下来其他实例就无法从那个实例拉取，如果你开启了消息持久化，让rabbitmq落地存储消息的话，消息不一定会丢，得等这个实例恢复了，然后在可以继续从这个queue拉取数据。

所以这种根本就没有高可用，就是提升了吞吐量，就是说让集群中多个节点来服务某个queue的读写操作。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 7]  
缺点1：可能会在rabbitmq集群内部产生大量的数据传输。  
缺点2：可用性几乎没有保障，如果queue所在的节点宕机，queue的数据就丢失了，就没法消费了。

3）镜像集群模式  
这种模式，才是所谓的rabbitmq的高可用模式，跟普通集群模式不一样的是，你创建的queue，无论元数据还是queue里的消息都会存在于多个实例上，然后每次你写消息到queue的时候，都会自动把消息到多个实例的queue里进行消息同步。

这样的话，好处在于，你任何一个机器宕机了，没事，别的机器都可以用。坏处在于，第一，这个性能消耗非常大，消息同步所有机器，导致网络带宽压力和消耗很重！第二，这样扩展性很差，如果某个queue负载很重，你加机器，新增的机器也包含了这个queue的所有数据，并没有办法线性扩展你的queue。

那么怎么开启这个策略呢？其实很简单，rabbitmq有一个很好的管理控制台，就是在后台新增一个策略，这个策略是镜像集群模式的策略，指定的时候可以要求数据同步到所有节点的，也可以要求就同步到指定数量的节点，然后你在创建queue的时候，应用这个策略，就会自动将数据同步到其他的节点上了。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 8]  
（kafka是分布式高可用的）。

# 7. 如何保证消息不被重复消费？如何保证消费的时候是幂等的？ #

*  Kafka消费端可能出现的重复消费问题：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 9]  
    就是类似于消费者在消费消息的时候会定期给消息队列发送一个行号，表示自己消费了哪些消息，可是如果重启了，那在系统中缓存的行号就没有更新到kafka上，重启后，要从kafka拿行号，就是上一次提交了的行号，那么上次没提交的那几行就要被重复消费一次。这样如果消息是对数据库的操作的话，就容易导致幂等性不正确。
    
    其实重复消费并不可怕，可怕的是没有考虑到重复消费对数据库幂等性的影响。
    
    一条数据重复出现两次，数据库里就只有一条数据，就保证了系统的幂等性。
    
    幂等性，通俗来说，就是一个数据，或一个请求，给你重复请求多次，确保对应的数据不会改变，不能出错。
    
    那么，`如何保证消息队列的幂等性呢？`
    
    其实还是得结合业务来思考，有如下几种思路：
    
    （1）如果你拿个数据要写库，可以先根据主键查一下，如果这数据都有了，就别插入了，update一下就好了。  
    （2）比如是写redis，那就没问题，反正都是set，天然幂等性。  
    （3）入股不是上面两个场景，那要稍微复杂一点，需要让生产者发送每条数据的时候，里面加一个全局唯一的id，类似订单id之类的东西，然后你这里消费到了之后（消费之前），先根据这个id去比如redis里查一下，之前消费过吗？如果没有消费过，就进行消费，然后这个id写redis。如果消费过了，就别处理了，保证别重复处理相同的消息即可。

# 8. 如何保证消息的可靠性传输？要是消息丢失了怎么办？ #

*  rabbitmq可能存在的数据丢失问题  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 10]  
    有三种情况：  
    1、写消息的过程中，消息都没到rabbitmq在网络传输过程中就丢了，或者是消息到了rabbitmq但是人家内部出错了没保存下来。  
    2、rabbitmq接收到消息之后先暂存在自己的内存里，结果消费者还没来得及消费，rabbitmq自己挂掉了，就导致暂存在内存里的数据就给搞丢了。  
    3、消费者消费到了这个消息，但是还没来得及处理，自己就挂掉了，但是rabbitmq以为这个消费者已经处理完了。

所以解决也要从这三种情况来解决：  
**1）生产者弄丢了数据**

可以选择用rabbitmq提供的事务功能，就是生产者发送数据之前开启rabbitmq事务（`channel.txSelect`），然后发送消息，如果消息没有成功被rabbitmq接收到，那么生产者会受到异常报错，此时就可以回滚事务（`channel.txRollback`），然后重试发送消息；如果收到了消息，那么可以提交事务（`channel.txCommit`）。但是问题是，rabbitmq事务机制一搞，基本上吞吐量会下来（因为是同步的会阻塞），因为太耗性能。

所以一般来说，如果你要确保说写rabbitmq的消息别丢，可以开启confirm模式，在生产者那里设置开启confirm模式之后，你每次写的消息都会分配一个唯一的id，然后如果写入了rabbitmq中，rabbitmq会给你回传一个ack消息，告诉你说这个消息ok了。如果rabbitmq没能处理这个消息，会回调你一个nack接口，告诉你这个消息接受失败，你可以重试。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 11]  
**2）rabbitmq弄丢了数据**

就是rabbitmq自己弄丢了数据，这个你必须开启rabbitmq的持久化，就是消息写入之后会持久化到磁盘，哪怕是rabbitmq自己挂了，恢复之后会自动读取之前存储的数据，一般数据不会丢。除非极其罕见的是，rabbitmq还没持久化，自己就挂了，可能导致少量数据会丢失的，但是这个概率较小。

设置持久化有两个步骤，第一个是创建queue的时候将其设置为持久化的，这样就可以保证rabbitmq持久化queue的元数据，但是不会持久化queue里的数据；第二个是发送消息的时候将消息的deliveryMode设置为2，就是将消息设置为持久化的，此时rabbitmq就会将消息持久化到磁盘上去。必须要同时设置这两个持久化才行。rabbitmq哪怕是挂了，再次重启，也会从磁盘上重启恢复queue，恢复这个queue里的数据。

而且持久化可以跟生产者那边的confirm机制配置起来，只有消息被持久化到磁盘之后，才会通知生产者ack了，所以哪怕是在持久化到磁盘之前，rabbitmq挂了，数据丢了，生产者收不到ack，你也是可以自己重发的。

哪怕是你给rabbitmq开启了持久化机制，也有一种可能，就是这个消息写到了rabbitmq中，但是还没来得及持久化到磁盘上，结果不巧，此时rabbitmq挂了，就会导致内存里的一点点数据会丢失。

**3）消费端弄丢了数据**  
如果消费端打开了autoAck机制就可能会有数据丢失问题，就是在消费端接收到数据之后自动回传一个ack表示自己消费了这条消息（可是事实还没消费），如果此时消费端宕机，这条消息就丢失了，所以不要使用autoAck，在消费端消费完消息后才回传ack。

# 9. 如何保证消息的顺序性？ #

举个例子，一个mysql binlog同步的系统，在mysql中增删改一条数据，对应出来了增删改3条binlog，接着这三条binlog发送到MQ里面，到消费出来一次执行，这是要保证顺序性的。不然本来是：增加、修改、删除，如果顺序乱了变成删除、修改、增加，就全乱了。本来数据同步过来，应该最后这个数据是被删除的，结果因为搞错了顺序，最后这个数据保留了下来，数据同步就出错了。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 12]  
如上图，消息的正确顺序是1，2，3结果经由三个消费者后到目标数据库成了2，1，3。

*  RabbitMQ如何保证消息的顺序性  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 13]  
    如上图，这里维护三个队列，每个队列只能被一个消费者消费，需要保证顺序性的消息都发送到一个队列中，也就只能被一个消费者顺序消费，也就保证了顺序性。

# 10. 如何解决消息队列的延时以及过期失效问题？消息队列满了以后该怎么处理？有几百万消息持续积压几小时，说说怎么解决？ #

如果消费端出故障了，会导致大量的消息积压在mq，假如积压了几千万条消息，即使重启了，可能也要傻傻的等待几个小时消费完毕。而且持续积压可能导致内存不够。

一般这个时候，只能操作临时紧急扩容了，具体操作步骤和思路如下：  
1）先修复consumer的问题，确保其恢复消费速度，然后将现有consumer都停掉  
2）临时建立好原先10倍或者20倍的queue数量  
3）然后写一个临时的分发数据的consumer程序，这个程序部署上去消费积压的数据，消费之后不做耗时的处理，直接均匀轮询写入临时建立好的10倍数量的queue  
4）接着临时征用10倍的机器来部署consumer，每一批consumer消费一个临时queue的数据  
5）这种做法相当于是临时将queue资源和consumer资源扩大10倍，以正常的10倍速度来消费数据  
6）等快速消费完积压数据之后，得恢复原先部署架构，重新用原先的consumer机器来消费消息

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 14]  
如上图，这是本来的，现在我们修改消费者的代码，让他不去消费消息，而是转发给30个新的partition里，然后由30个新的消费者去消费消息，这样效率就快了10倍。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 15]  
消费完之后，将临时的30个消费者和30个partition下掉，恢复之前的消费者的消费功能，就回到了正常状态。

**这里我们假设再来第二个坑：**  
rabbitmq是可以设置过期时间的，就是TTL，如果消息在queue中积压超过一定时间就会被rabbitmq给清理掉，这个数据就没了。这就不是说数据会大量积压在mq里，而是大量的数据会直接搞丢。

所以一般我们不建议设置过期时间，如果设置了并且丢失了消息，我们可以采取批量重导，例如自己手动写程序，将丢失的消息一点一点查出来重新灌入到mq中。。。

**然后我们再来假设第三个坑**  
如果消息长时间积压，导致mq快写满了怎么办，其实就是上面两种方法，一种是临时加机器加快消费，一种是临时丢弃（如设置过期时间丢弃），后面再找回。。。

# 11. 如果让你写一个消息队列，该如何进行架构设计？说一下你的思路 #

可以从扩展性、持久化、可靠性、顺序性等来说，其实就是前面的。

# mysql binlog 同步数据 #

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/fbdf5b89115640e8a6e58c9c62db6280.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/2220d275a8144bb69b06f3753cd17ab2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/a2aab15072af40c09f138494c952b973.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/94965a7c265a42f2a2450e1839f701b1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/377dca110ed9476fa3ac474409b50633.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/06360fecadca4d69936b40d226d606ec.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/c8a15fa1e5484e3d997378759cb7d6dc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/f98ee90d8e2c465597bd395e50985aa6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/e0fa3b1a2c05450381450254da4e7013.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 9]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/85b974c42ef24fcab49b05b676611fe1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 10]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/8bbd04ca139b448cbfff5ca2e27c5e5c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 11]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/28b419f0d1264fba800190c55c362ac5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 12]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/006bacad943844688aeaad8a560a2151.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 13]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/b779afbd3a004f0fae19e6f0a42cc708.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 14]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/864098e0d5d34e0f86d11b2641a9a55d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 15]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/b2422b032a1d44e9930e78c368bcde81.png