HBase是一个复杂的分布式非结构化数据库，它将表中的数据按照行的方向切分成一个个的Region，并在若干RegionServer上上线，依靠所在RegionServer对外提供数据读写IO服务。一开始，表中数据由于很少，只有一个Region。随着数据越来越多，一个Region已难以满足频繁的数据读写请求，所以，Region开始分裂。分裂后的两个Region又会按照一定策略选择RegionServer上线，继续对外提供数据读写服务。并且，HBase作为一个分布式数据库，肯定需要考虑负载均衡，它会按照某些策略选择若干Region，在比较繁忙的RegionServer上下线，转移到较为空闲的RegionSever上线继续提供高质量的数据读写服务。所有涉及到的这些Region的上线、下线、分裂，以及我们还没提到的合并等等流程，在HBase内部都是通过不同组件之间发送事件，然后按照一定策略调度执行的。这就是HBase的事件处理模型。

        那么，HBase的事件处理模型是如何实现的呢？本文，我们就将研究下HBase内部事件处理模型的实现。

        在HBase中有一个抽象类EventHandler，定义如下：

@InterfaceAudience.Private
public abstract class EventHandler implements Runnable, Comparable<Runnable> {

        它实现了Runnable接口，说明其子类是一个线程，而且，在它内部定义了以下成员变量：

  // type of event this object represents
  // 该对象代表的事件类型
  protected EventType eventType;

  // 服务器
  protected Server server;

  // sequence id generator for default FIFO ordering of events
  // 默认的FIFO调度的事件的序列化ID生成器
  protected static final AtomicLong seqids = new AtomicLong(0);

  // sequence id for this event
  // 该事件的序列化ID
  private final long seqid;

  // Listener to call pre- and post- processing.  May be null.
  // 监听器，可能为空
  private EventHandlerListener listener;

  // Time to wait for events to happen, should be kept short
  // 等待事件发生的时间
  protected int waitingTimeForEvents;

  // 祖先
  private final Span parent;

        监听器listener是实现了EventHandlerListener接口的实例，接口定义如下：

  /**
   * This interface provides pre- and post-process hooks for events.
   * 为事件提供事前和事后处理钩子的接口
   */
  public interface EventHandlerListener {
    /**
     * Called before any event is processed
     * 任何事件执行前被调用
     * @param event The event handler whose process method is about to be called.
     */
    void beforeProcess(EventHandler event);
    /**
     * Called after any event is processed
     * 任何事件执行后被调用
     * @param event The event handler whose process method is about to be called.
     */
    void afterProcess(EventHandler event);
  }

        接口就定义了两个方法，一个是任何事件执行前被调用的beforeProcess()方法和任何事件执行后被调用的afterProcess()方法。

        抽象类EventHandler既然实现了Runnable接口，那么其子类肯定是一个线程，而且其功能的实现，必然在核心方法run()方法内。下面，我们就看下这个run()方法，代码如下：

  /**
   * 线程实现功能的主方法，run()方法，是不是很像一个模板方法啊
   */
  public void run() {
<span style="white-space:pre">	</span>  
<span style="white-space:pre">	</span>// 开启一个TraceScope
    TraceScope chunk = Trace.startSpan(this.getClass().getSimpleName(), parent);
    
    try {
      
      // 先执行监听器的beforeProcess()方法
      if (getListener() != null) getListener().beforeProcess(this);
      
      // 接着执行process()方法
      process();
      
      // 最后执行监听器的afterProcess()方法
      if (getListener() != null) getListener().afterProcess(this);
      
    } catch(Throwable t) {
    <span style="white-space:pre">	</span>
      // 处理事件异常t
      handleException(t);
      
    } finally {
      
      // 关闭TraceScope
      chunk.close();
    }
  }

        第一感觉是不是个模板方法呢？它的主要流程就是：

        1、开启一个TraceScope;

        2、先执行监听器的beforeProcess()方法；

        3、接着执行process()方法；

        4、最后执行监听器的afterProcess()方法；

        5、关闭TraceScope。

        如果中间出现Throwable异常，则调用handleException()方法处理事件异常。

        关于监听器的beforeProcess()方法和afterProcess()方法我们在上面已经提到过了，这里不再赘述。关键是看一下process()方法，其定义如下：

  /**
   * This method is the main processing loop to be implemented by the various
   * subclasses.
   * 
   * 核心方法process()方法是一个抽象方法，子类必须实现
   * @throws IOException
   */
  public abstract void process() throws IOException;

        它是一个抽象方法，也就意味着子类必须要实现它。并且，它是子类完成事件处理核心逻辑所必须执行的方法。

        另外，还实现了诸如获取监听器、设置监听器、获取优先级、获取事件序列ID等工具方法，十分简单，不再一一介绍，代码粘贴如下，读者可自行查看：

  /**
   * This method is the main processing loop to be implemented by the various
   * subclasses.
   * 
   * 核心方法process()方法是一个抽象方法，子类必须实现
   * @throws IOException
   */
  public abstract void process() throws IOException;

  /**
   * Return the event type
   * 获取时事件类型
   * @return The event type.
   */
  public EventType getEventType() {
    return this.eventType;
  }

  /**
   * Get the priority level for this handler instance.  This uses natural
   * ordering so lower numbers are higher priority.
   * 获取handler实例的优先级，数字越低级别越高
   * 
   * <p>
   * Lowest priority is Integer.MAX_VALUE.  Highest priority is 0.
   * <p>
   * Subclasses should override this method to allow prioritizing handlers.
   * <p>
   * Handlers with the same priority are handled in FIFO order.
   * <p>
   * @return Integer.MAX_VALUE by default, override to set higher priorities
   */
  public int getPriority() {
    return Integer.MAX_VALUE;
  }

  /**
   * 获取事件的序列号ID
   * @return This events' sequence id.
   */
  public long getSeqid() {
    return this.seqid;
  }

  /**
   * Default prioritized runnable comparator which implements a FIFO ordering.
   * <p>
   * Subclasses should not override this.  Instead, if they want to implement
   * priority beyond FIFO, they should override {@link #getPriority()}.
   * 
   * 实现可比较接口的compareTo()方法，先比较优先级Priority，谁的优先级越小谁就越小。
   * 优先级相同的话，再比较事件序列号ID，谁的事件序列号ID越小谁就越小
   */
  @Override
  public int compareTo(Runnable o) {
    EventHandler eh = (EventHandler)o;
    if(getPriority() != eh.getPriority()) {
      return (getPriority() < eh.getPriority()) ? -1 : 1;
    }
    return (this.seqid < eh.seqid) ? -1 : 1;
  }

  /**
   * 获取事件的监听器
   * @return Current listener or null if none set.
   */
  public synchronized EventHandlerListener getListener() {
    return listener;
  }

  /**
   * 设置事件的监听器
   * @param listener Listener to call pre- and post- {@link #process()}.
   */
  public synchronized void setListener(EventHandlerListener listener) {
    this.listener = listener;
  }

  @Override
  public String toString() {
    return "Event #" + getSeqid() +
      " of type " + eventType +
      " (" + getInformativeName() + ")";
  }

  /**
   * Event implementations should override thie class to provide an
   * informative name about what event they are handling. For example,
   * event-specific information such as which region or server is
   * being processed should be included if possible.
   */
  public String getInformativeName() {
    return this.getClass().toString();
  }

  /**
   * 处理事件异常，可能被覆写
   * Event exception handler, may be overridden
   * @param t Throwable object
   */
  protected void handleException(Throwable t) {
    LOG.error("Caught throwable while processing event " + eventType, t);
  }

        接下来就有一个问题，继承了抽象类EventHandler的各种事件是如何被提交的？它们被提交到哪里，又是如何被调度执行的呢？别慌，下面我一一为大家解答。

        首先在HRegionServer上有一个叫做service的成员变量，定义如下：

  // Instance of the hbase executor service.
  // HBase执行服务的实例
  protected ExecutorService service;

        它是HRegionServer上执行各种事件的ExecutorService实例，而ExecutorService提供了通用的事件执行机制，它抽象了线程池、队列，EventType可以被提交，使用线程处理被添加到队列中的对象。如果要创建一个的服务， 创建该类的一个实例，并调用实例的startExecutorService()方法。当服务完成后，调用shutdown()方法。

        那么事件是如何被提交的呢？我们以Region上线为例，在HRegionServer对外提供RPC服务的RSRpcServices类的openRegion()方法中，Region上线事件OpenRegionHandler是通过以下方式被提交的，代码如下：

          // If there is no action in progress, we can submit a specific handler.
          // Need to pass the expected version in the constructor.
          // 如果对应Region上没有相关的操作在进行，我们可以提交一个特定的处理者
          if (region.isMetaRegion()) {
            regionServer.service.submit(new OpenMetaHandler(
              regionServer, regionServer, region, htd, masterSystemTime, coordination, ord));
          } else {
            regionServer.updateRegionFavoredNodesMapping(region.getEncodedName(),
              regionOpenInfo.getFavoredNodesList());
            regionServer.service.submit(new OpenRegionHandler(
              regionServer, regionServer, region, htd, masterSystemTime, coordination, ord));
          }

        它就是通过HRegionServer中成员变量service的submit()方法，来提交OpenRegionHandler事件的。