精华内容
下载资源
问答
  • Kafka 消息可靠

    千次阅读 2018-07-25 08:50:03
    在 Kafka 工作机制 一文提及了 Kafka 消息的不可靠。本文就 Kafka 消息的三种不可靠(重复、丢失、乱序),分析它们出现的内部原因和解决办法。 作者:王克锋 出处:...

    Kafka 工作机制 一文提及了 Kafka 消息的不可靠性。本文就 Kafka 消息的三种不可靠性(重复、丢失、乱序),分析它们出现的内部原因和解决办法。

    作者:王克锋
    出处:https://kefeng.wang/2017/11/22/kafka-reliability/
    版权:自由转载-非商用-非衍生-保持署名,转载请标明作者和出处。

    1 Kafka 消息的问题

    Kafka就比较适合高吞吐量并且允许少量数据丢失的场景,如果非要保证“消息只读取一次”,可以使用JMS。
    参考: http://blog.csdn.net/u012050154/article/details/78592854

    Kafka Producer 消息发送有两种方式(配置参数 producer.type):

    • producer.type=sync(默认值): 后台线程中消息发送是同步方式,对应的类为 kafka.producer.SyncProducer;
    • producer.type=async: 后台线程中消息发送是异步方式,对应的类为 kafka.producer.AyncProducer;优点是可批量发送消息(消息个数达到 batch.num.messages=200 或时间达到 “ 时发送)、吞吐量佳,缺点是发送不及时可能导致丢失;

    对于同步方式(producer.type=sync)?Kafka Producer 消息发送有三种确认方式(配置参数 acks):

    • acks=0: producer 不等待 Leader 确认,只管发出即可;最可能丢失消息,适用于高吞吐可丢失的业务;
    • acks=1(默认值): producer 等待 Leader 写入本地日志后就确认;之后 Leader 向 Followers 同步时,如果 Leader 宕机会导致消息没同步而丢失,producer 却依旧认为成功;
    • acks=all/-1: producer 等待 Leader 写入本地日志、而且 Leader 向 Followers 同步完成后才会确认;最可靠。

    Kafka Consumer 有两个接口:

    • Low-level API: 消费者自己维护 offset 等值,可以完全控制;
    • High-level API: 封装了对 parition 和 offset 的管理,使用简单;可能遇到 Consumer 取出消息并更新了 offset,但未处理消息即宕机,从而相当于消息丢失;

    Kafka 支持 3 种消息传递语义

    • 最多一次 -消息可能会丢失,但永远不会重新发送。consumer.poll(); consumer.commitOffset(); processMsg(messages);
    • 至少一次 -消息永远不会丢失,但可能会重新传递。consumer.poll(); processMsg(messages); consumer.commitOffset();
    • 恰恰一次 - 这就是人们真正想要的,每条信息只传递一次。以事务来保证。

    2 消息重复

    • 根本原因:已经消费了数据,但是 offset 没提交。
    • 外在原因:(1)消费数据后、提交 offset 前,线程被杀;
      (2)设置 offset 为自动提交,consumer.close() 之前 consumer.unsubscribe();
      (3)consumer 取了一批数据,尚未处理完毕时,达到了 session.timeout.ms,导致没有接收心跳而挂掉,自动提交offset失败,下次会重复消费本批消息;
    • 解决办法:(1)唯一 ID 保存在外部介质中,每次消费时根据它判断是否已处理;
      (2)如果在统计用,丢失几条关系不大,则无需理会;
      (3)如果消费者来不及处理,可以这样优化:增加分区以提高并行能力;增加消费者线程;关闭自动提交 enable.auto.commit=false

    3 消息丢失

    • 根本原因:已经提交了 offset,但数据在内存中尚未处理,线程就被杀掉。
      同步模式下,确认机制设置为-1(不可为1),即让消息写入Leader和Follower之后再确认消息发送成功;
      异步模式下,设置为不限制阻塞超时时间(不可为acks=0),当缓冲区满时不清空缓冲池,而是让生产者一直处于阻塞状态;

    4 消息乱序

    传统的队列,在并行处理时,由于网络故障或速度差异,尽管服务器传递是有序的,但消费者接收的顺序可能不一致;
    Kafka 在主题内部有分区,并行处理时,每个分区仅由消费者组中的一个消费者使用,确保了消费者是该分区的唯一读者,并按顺序使用这些数据。
    但是它也仅仅是保证Topic的一个分区顺序处理,不能保证跨分区的消息先后处理顺序,除非只提供一个分区。

    展开全文
  • 如何保证消息的幂等 所谓的幂等其实就是保证同一条消息不会重复或者重复消费了也不会对系统数据造成异常。 出现消息重复消费的情况 拿RabbitMQ来说的话,消费者在消费完成一条消息之后会向MQ回复一个ACK(可以...

    如何保证消息的幂等性

    所谓的幂等性其实就是保证同一条消息不会重复或者重复消费了也不会对系统数据造成异常。

    出现消息重复消费的情况

    拿RabbitMQ来说的话,消费者在消费完成一条消息之后会向MQ回复一个ACK(可以配置自动ACK或者手动ACK) 来告诉MQ这条消息已经消费了。假如当消费者消费完数据后,准备回执ACK时,系统挂掉了,MQ是不知道该条消息已经被消费了。所以重启之后MQ会再次发送该条消息,导致消息被重复消费,如果此时没有做幂等性处理,可能就会导致数据错误等问题。

    如何保证消息队列消费的幂等性

    这一块应该还是要结合业务来选择合适的方法,有以下几个方案:

    • 消费数据为了单纯的写入数据库,可以先根据主键查询数据是否已经存在,如果已经存在了就没必要插入了。或者直接插入也没问题,因为可以利用主键的唯一性来保证数据不会重复插入,重复插入只会报错,但不会出现脏数据。
    • 消费数据只是为了缓存到redis当中,这种情况就是直接往redis中set value了,天然的幂等性。
    • 针对复杂的业务情况,可以在生产消息的时候给每个消息加一个全局唯一ID,消费者消费消息时根据这个ID去redis当中查询之前是否消费过。如果没有消费过,就进行消费并将这个消息的ID写入到redis当中。如果已经消费过了,就无需再次消费了。

    如何保证消息的可靠性

    在将消息投入到MQ时,有可能会发生消息投递失败、消息丢失的问题,如果刚好丢失的是一些核心消息,例如money相关的,那就凉凉了…

    出现消息丢失的情况

    还是拿RabbitMQ来说…
    image

    从图中可以看到一共有以下三种可能出现消息丢失的情况:

    • 生产者弄丢了消息

    生产者在将数据发送到MQ的时候,可能由于网络等原因造成消息投递失败

    • MQ自身弄丢了消息

    未开启RabbitMQ的持久化,数据存储于内存,服务挂掉后队列数据丢失;
    开启了RabbitMQ持久化,消息写入后会持久化到磁盘,但是在落盘的时候挂掉了,不过这种概率很小

    • 消费者弄丢了消息

    消费者刚接收到消息还没处理完成,结果消费者挂掉了…

    保证消息可靠性的方法

    针对以上三种情况,每种情况都有对应的处理方法:

    • 生产者弄丢消息时的解决方法

    方法一:生产者在发送数据之前开启RabbitMQ的事务

    // 开启事务
    channel.txSelect
    try {
        // 这里发送消息
    } catch (Exception e) {
        channel.txRollback
        // 这里再次重发这条消息
    }
    // 提交事务
    channel.txCommit
    
    

    采用该种方法由于事务机制,会导致吞吐量下降,太消耗性能。

    方法二:开启confirm模式

    使用springboot时在application.yml配置文件中做如下配置

    spring:
      rabbitmq:
        addresses: 127.0.0.1
        port: 5672
        username: guest
        password: guest
        # 发送者开启 confirm 确认机制
        publisher-confirm-type: correlated
    

    实现confirm回调接口

    @Slf4j
    public class ConfirmCallbackService implements RabbitTemplate.ConfirmCallback {
    
        @Override
        public void confirm(CorrelationData correlationData, boolean ack, String cause) {
            if (!ack) {
                log.error("消息发送异常!");
                //可以进行重发等操作
            } else {
                log.info("发送者已经收到确认,correlationData={} ,ack={}, cause={}", correlationData, ack, cause);
            }
        }
    }
    

    生产者发送消息时设置confirm回调

    @Slf4j
    @Configuration
    public class RabbitMqConfig {
    
         @Bean
        public ConfirmCallbackService confirmCallbackService() {
            return new ConfirmCallbackService();
        }
        
        @Bean
        public RabbitTemplate rabbitTemplate(@Autowired CachingConnectionFactory factory) {
            RabbitTemplate rabbitTemplate = new RabbitTemplate(factory);
    
            /**
             * 消费者确认收到消息后,手动ack回执回调处理
             */
            rabbitTemplate.setConfirmCallback(confirmCallbackService());
            return rabbitTemplate;
        }
        
        //其他配置代码
        ......
    
    }
    

    小结: 事务机制和 confirm机制最大的不同在于,事务机制是同步的,你提交一个事务之后会阻塞在那儿,但是 confirm机制是异步的,你发送个消息之后就可以发送下一个消息,RabbitMQ 接收了之后会异步回调confirm接口通知你这个消息接收到了。一般在生产者这块避免数据丢失,建议使用用 confirm 机制。

    • MQ自身弄丢消息时的解决方法

    第一步: 创建queue时设置为持久化队列,这样可以保证RabbitMQ持久化queue的元数据,此时还是不会持久化queue里的数据

        @Bean(QUEUE_IOT_TOIN)
        public Queue createIotQueue() {
            return new Queue(QUEUE_IOT_TOIN, true);
        }
    

    第二步: 发送消息时将消息的deliveryMode设置为持久化,此时queue中的消息才会持久化到磁盘。

        public void sendToUploadMsg(Object obj, String routingKey) {
            try {
    
                String jsonString = JSON.toJSONString(obj);
                rabbitTemplate.convertAndSend(EXCHANGE_IOT, routingKey, jsonString, message -> {
                    //设置该条消息持久化
                    message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
                    return message;
                }, new CorrelationData(UUIDUtil.generate()));
            } catch (Exception e) {
                log.info(routingKey + "发送消息异常!");
            }
        }
    

    同时设置queue和message持久化以后,RabbitMQ 挂了再次重启,也会从磁盘上重启恢复 queue,恢复这个 queue 里的数据,保证数据不会丢失。

    但是就算开启持久化机制,也有可能出现上面说的的消息落盘时服务挂掉的情况。这时可以考虑结合生产者的confirm机制来处理,持久化机制开启后消息只有成功落盘时才会通过confirm回调通知生产者,所以可以考虑生产者在生产消息时维护一个正在等待消息发送确认的队列,如果超过一定时间还没从confirm中收到对应消息的反馈,自动进行重发处理。

    • 消费者自身弄丢消息时的解决方法

    关闭自动ACK,使用手动ACK。RabbitMQ中有一个ACK机制,默认情况下消费者接收到到消息,RabbitMQ会自动提交ACK,之后这条消息就不会再发送给消费者了。我们可以更改为手动ACK模式,每次处理完消息之后,再手动ack一下。不过这样可能会出现刚处理完还没手动ack确认,消费者挂了,导致消息重复消费,不过我们只需要保证幂等性就好了,重复消费也不会造成问题。

    在springboot中修改application.yml配置文件更改为手动ack模式

    spring:
      rabbitmq:
        addresses: 127.0.0.1
        port: 5672
        username: guest
        password: guest
        # 发送者开启 confirm 确认机制
        publisher-confirm-type: correlated
        # 发送者开启 return 确认机制
        publisher-returns: true
        listener:
          simple:
            concurrency: 10
            max-concurrency: 10
            prefetch: 1
            auto-startup: true
            default-requeue-rejected: true
            # 设置消费端手动 ack
            acknowledge-mode: manual
            # 是否支持重试
            retry:
              enabled: true
    

    消费端手动ack参考代码:

        @RabbitHandler
        public void handlerMq(String msg, Channel channel, Message message) throws IOException {
            try {
                //业务处理代码
                ......
            
                //手动ACK
                channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
                
            } catch (Exception e) {
                if (message.getMessageProperties().getRedelivered()) {
                    log.error("消息已重复处理失败,拒绝再次接收...", e);
                    channel.basicReject(message.getMessageProperties().getDeliveryTag(), false); // 拒绝消息
                } else {
                    log.error("消息即将再次返回队列处理...", e);
                    channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
                }
            }
    
    
        }
    

    RabbitMQ保证消息可靠性总结:
    image


    如何保证消息的顺序性

    消息在投入到queue的时候是有顺序,如果只是单个消费者来处理对应的单个queue,是不会出现消息错乱的问题。但是在消费的时候有可能多个消费者消费同一个queue,由于各个消费者处理消息的时间不同,导致消息未能按照预期的顺序处理。其实根本的问题就是如何保证消息按照预期的顺序处理完成

    出现消费顺序错乱的情况

    • 为了提高处理效率,一个queue存在多个consumer
      image

    • 一个queue只存在一个consumer,但是为了提高处理效率,consumer中使用了多线程进行处理
      image

    保证消息顺序性的方法

    • 将原来的一个queue拆分成多个queue,每个queue都有一个自己的consumer。该种方案的核心是生产者在投递消息的时候根据业务数据关键值(例如订单ID哈希值对订单队列数取模)来将需要保证先后顺序的同一类数据(同一个订单的数据) 发送到同一个queue当中。
      image

    • 一个queue就一个consumer,在consumer中维护多个内存队列根据业务数据关键值(例如订单ID哈希值对内存队列数取模)将消息加入到不同的内存队列中,然后多个真正负责处理消息的线程去各自对应的内存队列当中获取消息进行消费。
      image

    RabbitMQ保证消息顺序性总结:
    核心思路就是根据业务数据关键值划分成多个消息集合,而且每个消息集合中的消息数据都是有序的,每个消息集合有自己独立的一个consumer。多个消息集合的存在保证了消息消费的效率,每个有序的消息集合对应单个的consumer也保证了消息消费时的有序性。


    参考文章:

    https://gitee.com/shishan100/Java-Interview-Advanced/blob/master/docs/high-concurrency/how-to-ensure-the-order-of-messages.md

    https://www.cnblogs.com/-wenli/p/13047059.html

    展开全文
  • 微信公众号一次订阅消息

    千次阅读 2018-03-27 15:23:58
    公众号或网页使用一次订阅消息流程 第一步:需要用户同意授权,获取一次给用户推送一条订阅模板消息的机会 第二步:通过API推送订阅模板消息给到授权微信用户 说明 开发者可以通过一次订阅消息授权让微信...

    说明

    开发者可以通过一次性订阅消息授权让微信用户授权第三方移动应用(接入说明)或公众号,获得发送一次订阅消息给到授权微信用户的机会。授权微信用户可以不需要关注公众号。微信用户每授权一次,开发者可获得一次下发消息的权限。(注意:同一用户在同一scene场景值下的多次授权不累积下发权限,只能下发一条。若要订阅多条,需要不同scene场景值)

    消息下发位置说明:对于已关注公众号的,消息将下发到公众号会话里;未关注公众号的,将下发到服务通知。


    公众号或网页使用一次性订阅消息流程

    第一步:需要用户同意授权,获取一次给用户推送一条订阅模板消息的机会

    在确保微信公众帐号拥有订阅消息授权的权限的前提下(已认证的公众号即有权限,可登陆公众平台在接口权限列表处查看),引导用户在微信客户端打开如下链接:
    https://mp.weixin.qq.com/mp/subscribemsg?action=get_confirm&appid=wxaba38c7f163da69b&scene=1000&template_id=1uDxHNXwYQfBmXOfPJcjAS3FynHArD8aWMEFNRGSbCc&redirect_url=http%3a%2f%2fsupport.qq.com&reserved=test#wechat_redirect

    参数 是否必须 说明
    action 直接填get_confirm即可
    appid 公众号的唯一标识
    scene 重定向后会带上scene参数,开发者可以填0-10000的整形值,用来标识订阅场景值
    template_id 订阅消息模板ID,登录公众平台后台,在接口权限列表处可查看订阅模板ID
    redirect_url 授权后重定向的回调地址,请使用UrlEncode对链接进行处理。 注:要求redirect_url的域名要跟登记的业务域名一致,且业务域名不能带路径。 业务域名需登录公众号,在设置-公众号设置-功能设置里面对业务域名设置。
    reserved 用于保持请求和回调的状态,授权请后原样带回给第三方。该参数可用于防止csrf攻击(跨站请求伪造攻击),建议第三方带上该参数,可设置为简单的随机数加session进行校验,开发者可以填写a-zA-Z0-9的参数值,最多128字节,要求做urlencode
    wechat_redirect 无论直接打开还是做页面302重定向时,必须带此参数

    用户同意或取消授权后会返回相关信息。如果用户点击同意或取消授权,页面将跳转至:
    redirect_url/?openid=OPENID&template_id=TEMPLATE_ID&action=ACTION&scene=SCENE

    参数 说明
    openid 用户唯一标识,只在用户确认授权时才会带上
    template_id 订阅消息模板ID
    action 用户点击动作,”confirm”代表用户确认授权,”cancel”代表用户取消授权
    scene 订阅场景值
    reserved 请求带入原样返回

    第二步:通过API推送订阅模板消息给到授权微信用户

    地址为:
    post-https://api.weixin.qq.com/cgi-bin/message/template/subscribe?access_token=ACCESS_TOKEN
    数据示例:

    {
        “touser”:”OPENID”,
        “template_id”:”TEMPLATE_ID”,
        “url”:”URL”,
        “miniprogram”:{
            “appid”:“xiaochengxuappid12345”,
            “pagepath”:“index?foo=bar”    
        },
        “scene”:”SCENE”,
        “title”:”TITLE”,
        “data”:{
            “content”:{
                “value”:”VALUE”,
                “color”:”COLOR”
            }
        }
    }
    参数 是否必须 说明
    touser 填接收消息的用户openid
    template_id 订阅消息模板ID
    url 点击消息跳转的链接,需要有ICP备案
    miniprogram 跳小程序所需数据,不需跳小程序可不用传该数据
    appid 所需跳转到的小程序appid(该小程序appid必须与发模板消息的公众号是绑定关联关系,并且小程序要求是已发布的)
    pagepath 所需跳转到小程序的具体页面路径,支持带参数,(示例index?foo=bar)
    scene 订阅场景值
    title 消息标题,15字以内
    data 消息正文,value为消息内容文本(200字以内),没有固定格式,可用\n换行,color为整段消息内容的字体颜色(目前仅支持整段消息为一种颜色)

    注:url和miniprogram都是非必填字段,若都不传则模板无跳转;若都传,会优先跳转至小程序。开发者可根据实际需要选择其中一种跳转方式即可。当用户的微信客户端版本不支持跳小程序时,将会跳转至url。

    展开全文
  • 【Kafka】Kafka无消息丢失配置

    万次阅读 2019-12-16 22:34:54
    2 kafka无消息丢失配置 broker delete.topic.enable=true min.insync.replicas=2 unclean.leader.election.enable=false unclean.leader.election.enable=false 关闭unclean leader选举,即不允许非ISR中的副本被...

    2 kafka无消息丢失配置

    • broker

      delete.topic.enable=true
      min.insync.replicas=2
      unclean.leader.election.enable=false
      

      unclean.leader.election.enable=false

      关闭unclean leader选举,即不允许非ISR中的副本被选举为leader,从而避免broker端因日志水位截断而造成的消息丢失。

      replication.factor>=3

      设置成3主要是参考了Hadoop及业界通用的三备份原则,其实这里想强调的是一定要使用多个副本来保存分区的消息。

      min.insync.replicas>1

      用于控制某条消息至少被写入到ISR中的多少个副本才算成功,设置成大于1是为了提升producer端发送语义的持久性。记住只有在producer端acks被设置成all或-1时,这个参数才有意义。在实际使用时,不要使用默认值。

      确保replication.factor>min.insync.replicas若两者相等,那么只要有一个副本挂掉,分区就无法正常工作,虽然有很高的持久性但可用性被极大地降低了。推荐配置成 replication.factor=min.insyn.replicas+1。

    • produce

      block.on.buffer.full = true

    ​ 尽管该参数在0.9.0.0已经被标记为“deprecated”,但鉴于它的含义非常直观,所以这里还是显式设置它为true,使得producer将一直等待缓冲区直至其变为可用。否则如果producer生产速度过快耗尽了缓冲区,producer将抛出异常

    acks=all

    ​ 很好理解,所有follower都响应了才认为消息提交成功,即"committed"

    retries = MAX

    ​ 无限重试,直到你意识到出现了问题:

    max.in.flight.requests.per.connection = 1

    ​ 限制客户端在单个连接上能够发送的未响应请求的个数。设置此值是1表示kafka broker在响应请求之前client不能再向同一个broker发送请求。注意:设置此参数是为了避免消息乱序

    使用KafkaProducer.send(record, callback)而不是send(record)方法 自定义回调逻辑处理消息发送失败callback逻辑中最好显式关闭producer:close(0) 注意:设置此参数是为了避免消息乱序

    unclean.leader.election.enable=false

    ​ 关闭unclean leader选举,即不允许非ISR中的副本被选举为leader,以避免数据丢失

    replication.factor >= 3

    ​ 这个完全是个人建议了,参考了Hadoop及业界通用的三备份原则

    min.insync.replicas > 1

    ​ 消息至少要被写入到这么多副本才算成功,也是提升数据持久性的一个参数。与acks配合使用.保证replication.factor > min.insync.replicas 如果两者相等,当一个副本挂掉了分区也就没法正常工作了。通常设置replication.factor = min.insync.replicas + 1即可

    • consume

    consumer端丢失消息的情形比较简单:如果在消息处理完成前就提交了offset,那么就有可能造成数据的丢失。由于Kafka consumer默认是自动提交位移的,所以在后台提交位移前一定要保证消息被正常处理了,因此不建议采用很重的处理逻辑,如果处理耗时很长,则建议把逻辑放到另一个线程中去做。为了避免数据丢失,现给出两点建议:

      enable.auto.commit=false  关闭自动提交位移
      在消息被完整处理之后再手动提交位移
    
    展开全文
  • RabbitMQ之消息的可靠

    千次阅读 多人点赞 2020-03-25 01:21:01
    那么消息传输的可靠就至关重要了,说到这里,我们先看一下Rabbit MQ的整个工作流程: 从上面一张图中,可以很容易知道,消息是由生产者发出,流经Broker(信道->交换机->队列),再到消费者消费完毕,这就是...
  • 可靠性消息事务实现

    千次阅读 2017-10-21 13:09:34
    本方案基于外部事件表(Mysql)+MQ(ActiveMQ)+SpringCloud方式提供事务型消息发送。此方案并不依赖特定的事件表及MQ,TPS受限时可进行替换。主要应用在事务中包含的重接口、第三方系统调用等,以实现异步化,保证...
  • Strom 消息可靠保障机制和Ack原理

    千次阅读 2016-10-11 15:33:12
    Strom 消息可靠保障机制和Ack原理Storm提供了消息处理的保障机制,可以保证从Spout发射出的每个tuple都得到完整的处理。当然Storm消息处理保障机制的前提是你使用了这种特性,如果你的业务对偶尔丢失的tuple不敏感...
  • RabbitMQ消息幂等之全局唯一ID

    千次阅读 2019-07-21 20:36:20
    消息幂等,其实就是保证同一个消息不被消费者重复消费两次。当消费者消费完消息之后,通常会发送一个ack应答确认信息给生产者,但是这中间有可能因为网络中断等原因,导致生产者未能收到确认消息,由此这条消息将...
  • 分别是优先级队列、消息顺序消息分发、持久化。 正文 目录 前言 正文 优先级队列 消息顺序 消息分发 持久化 优先级队列 顾名思义,优先级高的具备优先消费的特权。 设置方式是在声明队列的时候...
  • 分布式消息最终一致解决方案

    千次阅读 2019-03-22 13:59:41
    多个服务之间使用自己单独维护的数据库,它们彼此之间不在同一个事务中,假如A执行成功了,B执行却失败了,而A的事务此时已经提交,无法回滚,那么最终就会导致两边数据不一致的问题;尽管很早之前就有基于两阶段...
  • 一个密码系统的安全主要与两个方面的因素有关。 (1)一个是所使用密码算法本身的保密强度。密码算法的保密强度取决于密码设计水平、破译技术等。可以说一个密码系统所使用密码算法的保密强度是该系统安全的...
  • RabbitMQ消息最终一致解决方案

    千次阅读 2019-09-29 10:50:38
    RabbitMQ消息最终一致解决方案 随着分布式服务架构的流行与普及,原来在单体应用中执行的多个逻辑操作,现在被拆分成了多个服务之间的远程调用。虽然服务化为我们的系统带来了水平伸缩的能力,然而随之而来挑战...
  • 在伸缩方面,由于消息队列服务器上的数据可以看作是被即时处理的,因此类似 于状态的服务器,伸缩设计比较简单。将新服务器加入分布式消息队列集群中,通 知生产者服务器更改消息队列服务器列表即可。 在可用...
  • Kafka 幂等,事物,消息可靠

    千次阅读 2018-06-07 16:46:53
    本文结合在使用Kafka中的使用,和遇到的问题1.Kafka中如何保障发送消息的可靠?首先我们在创建一个Producer是,可以设置的一些参数如下:1(默认):这意味着producer在ISR中的leader已成功收到的数据并得到确认后...
  • 消息中间件MQ与RabbitMQ面试题(2020最新版)

    万次阅读 多人点赞 2020-03-01 11:11:21
    文章目录为什么使用MQ?MQ的优点消息队列有什么优缺点?RabbitMQ有什么优缺点?你们公司生产环境用的是...rabbitmq 的使用场景RabbitMQ基本概念RabbitMQ的工作模式如何保证RabbitMQ消息的顺序消息如何分发?消...
  • ActiveMQ中的消息持久

    千次阅读 2007-03-02 20:18:00
    这文章是在网上看到的,还没来得及试验,先拿下来再说。...939A197D2798715B!125.entry ActiveMQ很好的支持了消息的持久...消息持久对于可靠消息传递来说应该是一种比较好的方法,有了消息持久化,即使发送者和接受
  • 小插曲 本话题已收入视频讲座《Spring Cloud分布式事务解决...本文对比 二阶段事务、最大努力交付以及消息最终一致,并给出部分解决方案,最终一致方案参考阿里RockMQ事务消息:http://blog.csdn.net/chunlongyu
  • 2. 最终一致(基于可靠消息) 2.1 消息发送的一致 指产生消息的业务动作与消息发送的一致。(也就是说,如果业务操作成功,那么由这个业务操作所产生的消息一定要成功投递出去,否则就丢消息) 2.1.1 ...
  • TCP保护消息边界的解决

    千次阅读 2010-12-31 13:36:00
    面向流是指保护消息边界的,如果发送端连续发送数据,接收端有可能在一次接收动作中会接收两个或者更多的数据包。 那什么是保护消息边界呢?就是指传输协议把数据当做一条独立的消息在网上传输,接收端只能接收...
  • RabbitMQ消息中间件极速入门与实战 课程 RabbitMQ学习——高级特性 RabbitMQ消息中间件技术精讲(三)—— 深入...什么是生产端的可靠投递 保障消息的成功发出 保障MQ节点的成功接收 发送端收到MQ节点(Br...
  • 上游服务接收到信息,先保存在本地消息表中,保存失败直接返回退出,保存成功则通知消息服务器new一个新的消息对象,状态为NEW,表示这个可能要发送,,通知成功(注意这里的通知这一步需要为同步模式,不然会出现这种情况,...
  • 消息队列

    千次阅读 多人点赞 2019-09-19 21:42:59
    消息队列中间件是分布式系统中重要的组件,主要解决应用解耦,异步消息,流量削锋等问题,实现高性能,高可用,可伸缩和最终一致架构。目前使用较多的消息队列有ActiveMQ,RabbitMQ,ZeroMQ,Kafka,MetaMQ,...
  • 消息队列及消息中间件

    千次阅读 2018-08-03 10:08:35
    它具有 低耦合、可靠投递、广播、流量控制、最终一致 等一系列功能。 当前使用较多的 消息队列 有 RabbitMQ、RocketMQ、ActiveMQ、Kafka、ZeroMQ、MetaMQ 等,而部分 数据库 如 Redis、MySQL 以及 phxsql ...
  • 文章目录分布式事务(2PC、3PC、TCC、基于消息达到最终一致)二阶段提交(2PC)三阶段提交(3PC)TCC(Try-Confirm-Cancel)RocketMQ基于消息达到最终一致总结 分布式事务(2PC、3PC、TCC、基于消息达到最终一致...
  • 消息中间件产生的背景 1、在客户端与服务器进行通讯时,客户端调用后,必须等待服务对象完成处理返回结果才能继续执行,这个过程是基于请求与响应的同步过程。 2、客户与服务器对象的生命周期紧密耦合,客户进程和...
  • 消息队列MQ与微消息队列MQTT

    千次阅读 2019-11-10 20:24:35
    文章目录为什么要使用MQ消息队列1. 解耦(可用)2. 流量削峰3. 数据分发缺点MQ对比传统消息队列RocketMQ和微消息队列MQTT对比 https://www.jianshu.com/p/15081799d66b 为什么要使用MQ消息队列 1. 解耦(可用) ...
  • 设计模式学到最后,看起来既像这个,又像那个,不要在意这心,设计模式的核心是提升代码的扩展,如果达到了这点,又何必在于是什么设计模式呢。 一、场景问题 1.1 故事场景 经过多年爱情的经营,我和女...
  • 消息鉴别机制

    千次阅读 2018-10-09 16:47:22
    消息鉴别/认证(message authentication) 消息认证是一种允许通信者验证所收...* 还可能希望验证消息的时效(时间戳)及实体间消息流的相对顺序(序列号) 上述都属于数据完整范畴   消息鉴别机制: ...
  • 幂等浅谈 GameKing 2017.01.07 21:08* 字数 1155 阅读 467评论 0喜欢 1 概述 幂等原本是数学上的概念,即使公式:f(x)=f(f(x)) 能够成立的数学性质。用在编程领域,则意为对同一个系统,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 481,078
精华内容 192,431
关键字:

性无消息