Storm的ACK机制与编码实例

Storm为了保证每条数据成功被处理,实现至少一次语义，通过Storm的ACK机制可以对spout产生的每一个tuple进行跟踪;

tuple处理成功是指这个Tuple以及这个Tuple产生的所有子Tuple都被成功处理, 由每一个处理bolt通过OutputCollector的方法ack(tuple)来告知storm当前bolt处理成功，最终调用spout的ack方法；

处理失败是指这个Tuple或这个Tuple产生的所有Tuple中的任意一个tuple处理失败或者超时(超时时间由Config.TOPOLOGY_MESSAGE_TIMEOUT_SECS指定), 处理失败bolt调用OutputCollector的方法fail(tuple),来告知storm当前bolt处理失败，最终调用spout的fail方法重新发送失败的tuple,失败时storm不会自动重发失败的tuple，需要我们在spout中重新获取发送失败数据，手动重新发送一次。

Ack原理

Storm中有个特殊的task名叫acker，他们负责跟踪spout发出的每一个Tuple的Tuple树（因为一个tuple通过spout发出了，经过每一个bolt处理后，会生成一个新的tuple发送出去）。当acker（框架自启动的task）发现一个Tuple树已经处理完成了，它会发送一个消息给产生这个Tuple的那个task。对任意大的一个Tuple树，storm只需要恒定的20字节就可以进行跟踪。acker对于每个spout-tuple保存一个ack-val的校验值，它的初始值是0，然后每发射一个Tuple或Ack一个Tuple时，这个Tuple的id就要跟这个校验值异或一下，
并且把得到的值更新为ack-val的新值。那么假设每个发射出去的Tuple都被ack了，那么最后ack-val的值就一定是0。Acker就根据ack-val是否为0来判断是否完全处理，如果为0则认为已完全处理。

例如下图是一个简单的Topology：

开启Act机制

1.spout发射tuple的时候指定messageId
2.spout对发射的tuple进行缓存,否则spout无法获取发送失败的数据进行重发,
(这里到底系统里有没有缓存没有成功处理的tuple,比如接口conf.setMaxSpoutPending()是否只缓存了条数还是原始数据还要去查证一下)
3.spout要重写BaseRichSpout的fail和ack方法,spout根据messageId对于成功处理的tuple从缓存队列中删除，对于失败的tuple选择重发或做其它处理；
4.如果使用BasicBolt，BasicOutputCollector在emit新的tuple时自动与源tuple锚定，execute方法结束时源tuple会被自动ack或fail;
使用RichBolt在emit数据的时需显示指定该数据的源tuple，以保持tracker链路，即collector.emit(oldTuple, newTuple);
并且需要在execute执行成功后调用OutputCollector.ack(tuple), 当失败处理时，执行OutputCollector.fail(tuple);
5.设置acker数大于0，conf.setNumAckers(>0);

关闭Ack机制

1.在Tuple层面去掉可靠性。在发射Tuple的时候不指定MessageID来达到不不跟踪这个Tuple的目的
2.如果对于一个Tuple树里面的某一部分到底成不成功不是很关心，那么可以在Bolt发射这些Tuple的时候不锚定它们。
这样这些Tuple就不在Tuple树里面，也就不会被跟踪了。
3.把Config.TOPOLOGY_ACKERS设置成0。在这种情况下，Storm会在Spout发射一个Tuple之后马上调用Spout的ack方法，
也就是说这个Tuple树不会被跟踪。

例子程序：

 
 

   
   

    
    

   
   
   
   

    
    

     
     public 
     
     class RandomSentenceSpout extends BaseRichSpout {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     private SpoutOutputCollector _collector;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     private Random _rand;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     private ConcurrentHashMap<UUID, Values> _pending;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     public void open(Map map, TopologyContext topologyContext, SpoutOutputCollector spoutOutputCollector) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             _collector = spoutOutputCollector;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             _rand = 
     
     new Random();
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             _pending = 
     
     new ConcurrentHashMap<UUID, Values>();
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     public void nextTuple() {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             Utils.sleep(
     
     1000);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             String[] sentences = 
     
     new String[] {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
                
     
     "I write php",
    
    
   
   

   
   

    
    

   
   
   
   

    
    
                
     
     "I learning java",
    
    
   
   

   
   

    
    

   
   
   
   

    
    
                
     
     "I want to learn swool and tfs"
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             };
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             String sentence = sentences[_rand.nextInt(sentences.length)];
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             Values v = 
     
     new Values(sentence);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             UUID msgId = UUID.randomUUID();
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     this._pending.put(msgId, v);
     
     //spout对发射的tuple进行缓存
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             _collector.emit(v, msgId);
     
     //发射tuple时，添加msgId
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     public void declareOutputFields(OutputFieldsDeclarer outputFieldsDeclarer) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             outputFieldsDeclarer.declare(
     
     new Fields(
     
     "world"));
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     public void ack(Object msgId) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     this._pending.remove(msgId);
     
     //对于成功处理的tuple从缓存队列中删除
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     public void fail(Object msgId) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     this._collector.emit(
     
     this._pending.get(msgId), msgId);
     
     //当消息处理失败了，重新发射，当然也可以做其他的逻辑处理
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     public 
     
     class SplitSentence extends BaseRichBolt {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         OutputCollector _collector;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     public void prepare(Map map, TopologyContext topologyContext, OutputCollector outputCollector) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             _collector = outputCollector;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     public void execute(Tuple tuple) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             String sentence = tuple.getString(
     
     0);
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     for (String word : sentence.split(
     
     " "))
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 _collector.emit(tuple, 
     
     new Values(word));
     
     //发射tuple时进行锚定
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             _collector.ack(tuple);
     
     //对处理完的tuple进行确认
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     public void declareOutputFields(OutputFieldsDeclarer outputFieldsDeclarer) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             outputFieldsDeclarer.declare(
     
     new Fields(
     
     "word"));
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         }
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   
 
 

场景分析

1. Bolt挂掉了，一个tuple没有被ack,storm的超时机制在超时之后会把这个tuple标记为失败，从而可以重新处理。
2. Acker挂掉了： 这种情况下由这个acker所跟踪的所有spout tuple都会超时，也就会被重新处理。
3. Spout挂掉了： 在这种情况下给spout发送消息的消息源负责重新发送这些消息。
以上机制保证storm的高度容错性

另外Ack机制还常用于限流作用： 为了避免spout发送数据太快，而bolt处理太慢，常常设置pending数，当spout有等于或超过pending数的tuple没有收到ack或fail响应时，跳过执行nextTuple， 从而限制spout发送数据。
通过conf.put(Config.TOPOLOGY_MAX_SPOUT_PENDING, pending);设置spout pend数。

本文参考：
http://www.cnblogs.com/intsmaze/p/5918087.html
http://itindex.net/detail/55385-storm-trident-%E5%AD%A6%E4%B9%A0
http://www.tuicool.com/articles/vErmIb