【Spark】Spark 事件总线

本篇结构：

事件总线介绍
ListenerBus 继承体系
LiveListenerBus 详解
流程总结

一、事件总线介绍

Spark 定义了一个特质 ListenerBus，可以接受事件并且将事件提交到对应事件的监听器。

该特征主要有一个 listeners 成员，用于维护所有注册的监听器，其数据结构是一个线程安全的 CopyOnWriteArrayList[L]。

该特征还有几个主要的函数：

addListener：添加 listener
doPostEvent：给特定 listener 发送事件，该方法具体需要子类实现
findListenersByClass：根据类型查找 listener 列表
postToAll：把事件发送给所有的 listener，虽然 CopyOnWriteArrayList 是线程安全的，但 postAll 引入了“先检查后运行”的逻辑，因此该方法不是线程安全的。
removeListener：删除 listener
removeListenerOnError：内部调用 removeListener，可由子类覆盖

二、ListenerBus 继承体系

上图是 spark 2.1.0 版本事件总线的继承关系，版本不同，会略有不同。

每个 ListenerBus 用于将不同的 Event 投递到不同的 Listener 中，下面以主要分析下 LiveListenerBus。

三、LiveListenerBus 详解

LiveListenerBus 继承 SparkListenerBus，和其他 ListenerBus 不同的是， LiveListenerBus 是将事件都放到一个队列中，然后另外一个线程不断从队列获取事件，将事件异步投递给监听器，达到实时刷新UI界面数据的效果。

3.1、LiveListenerBus 中的属性：

// Cap the capacity of the event queue so we get an explicit error (rather than
// an OOM exception) if it's perpetually being added to more quickly than it's being drained.
private lazy val EVENT_QUEUE_CAPACITY = validateAndGetQueueSize()
private lazy val eventQueue = new LinkedBlockingQueue[SparkListenerEvent](EVENT_QUEUE_CAPACITY)

private def validateAndGetQueueSize(): Int = {
    val queueSize = sparkContext.conf.get(LISTENER_BUS_EVENT_QUEUE_SIZE)
    if (queueSize <= 0) {
      throw new SparkException("spark.scheduler.listenerbus.eventqueue.size must be > 0!")
    }
    queueSize
  }

private[spark] val LISTENER_BUS_EVENT_QUEUE_SIZE =
ConfigBuilder("spark.scheduler.listenerbus.eventqueue.size")
  .intConf
  .createWithDefault(10000)

eventQueue：是 SparkListenerEvent 事件的阻塞队列，队列大小可以通过 Spark 属性 spark.scheduler.listenerbus.eventqueue.size 进行配置，默认为 10000；

// Indicate if `start()` is called
private val started = new AtomicBoolean(false)
// Indicate if `stop()` is called
private val stopped = new AtomicBoolean(false)

started：标记 LiveListenerBus 的启动状态的 AtomicBoolean 类型的变量；
stopped：标记LiveListenerBus的停止状态的 AtomicBoolean 类型的变量；

/** A counter for dropped events. It will be reset every time we log it. */
private val droppedEventsCounter = new AtomicLong(0L)
/** When `droppedEventsCounter` was logged last time in milliseconds. */
@volatile private var lastReportTimestamp = 0L

droppedEventsCounter：使用 AtomicLong 类型对删除的事件进行计数，每当日志打印了 droppedEventsCounter 后，会将 droppedEventsCounter 重置为0；
lastReportTimestamp：记录最后一次日志打印 droppedEventsCounter 的时间戳；

// Indicate if we are processing some event
// Guarded by `self`
private var processingEvent = false

processingEvent：暗示当前正有事件在被 listenerThread 线程处理；

private val logDroppedEvent = new AtomicBoolean(false)

logDroppedEvent：标记是否由于 eventQueue 已满，导致新的事件被删除；

// A counter that represents the number of events produced and consumed in the queue
private val eventLock = new Semaphore(0)

eventLock：表示队列中事件产生和消费的一个计数器，当有新的事件到来时释放信号量，当对事件进行处理时获取信号量，eventLock = new Semaphore(0)；
listenerThread：异步处理事件的线程；

3.2、异步事件处理线程

  private val listenerThread = new Thread(name) {
    setDaemon(true)
    override def run(): Unit = Utils.tryOrStopSparkContext(sparkContext) {
      LiveListenerBus.withinListenerThread.withValue(true) {
        while (true) {
          eventLock.acquire()
          self.synchronized {
            processingEvent = true
          }
          try {
            val event = eventQueue.poll
            if (event == null) {
              // Get out of the while loop and shutdown the daemon thread
              if (!stopped.get) {
                throw new IllegalStateException("Polling `null` from eventQueue means" +
                  " the listener bus has been stopped. So `stopped` must be true")
              }
              return
            }
            postToAll(event)
          } finally {
            self.synchronized {
              processingEvent = false
            }
          }
        }
      }
    }
  }

代码不算复杂，主要逻辑是：

设置为 daemon thread；
不断获取信号量，如果没有就会阻塞，有信号释放才会往下运行（这是依靠 new Semaphore(0)实现的，在 spark 后面的版本中，是直接用阻塞队列的 take() 方法实现。）；
同步控制，将 processingEvent 设置为 true；
从 eventQueue 中获取事件；
调用超类 ListenerBus 的 postToAll 方法，对监听器进行遍历，并调用 SparkListenerBus 的 doPostEvent 方法对事件进行匹配后执行监听器的相应方法；；
每次循环结束同步控制，将 processingEvent 设置为 false；

3.3、异步事件处理线程的事件来源

DAGScheduler、SparkContext、BlockManagerMasterEndpoint、DriverEndpoint 及 LocalSchedulerBackend 都是 LiveListenerBus 的事件来源，它们都是通过调用 LiveListenerBus 的 post 方法将消息交给异步线程 listenerThread 处理的。

  def post(event: SparkListenerEvent): Unit = {
    if (stopped.get) {
      // Drop further events to make `listenerThread` exit ASAP
      logError(s"$name has already stopped! Dropping event $event")
      return
    }
    val eventAdded = eventQueue.offer(event)
    if (eventAdded) {
      eventLock.release()
    } else {
      onDropEvent(event)
      droppedEventsCounter.incrementAndGet()
    }

    val droppedEvents = droppedEventsCounter.get
    if (droppedEvents > 0) {
      // Don't log too frequently
      if (System.currentTimeMillis() - lastReportTimestamp >= 60 * 1000) {
        // There may be multiple threads trying to decrease droppedEventsCounter.
        // Use "compareAndSet" to make sure only one thread can win.
        // And if another thread is increasing droppedEventsCounter, "compareAndSet" will fail and
        // then that thread will update it.
        if (droppedEventsCounter.compareAndSet(droppedEvents, 0)) {
          val prevLastReportTimestamp = lastReportTimestamp
          lastReportTimestamp = System.currentTimeMillis()
          logWarning(s"Dropped $droppedEvents SparkListenerEvents since " +
            new java.util.Date(prevLastReportTimestamp))
        }
      }
    }
  }

先判断 LiveListenerBus 是否停止，停止记录错误日志，返回；
向eventQueue中添加事件：
- 如果成功，就释放信号量，这时 listenerThread 中的 eventLock.acquire() 就可以后去信号量，从队列取出事件进行后续操作；
- 如果失败，则移除事件 onDropEvent，并对删除事件计数器进行自增 droppedEventsCounter.incrementAndGet()；
如果有事件被删除，并且当前系统时间距离上一次打印 droppedEventsCounter 超过了 60 秒则重置 droppedEventsCounter 计算为0，并更新 lastReportTimestamp 为当前系统时间。

四、流程总结

用一张图总结下的 Spark 的事件总线大致的流程：

五、参考资料

这篇文章内容和《spark内核设计的艺术架构设计与实现》关于事件总线的描述章节相差不多，流程图也一样。之所以还要花费时间记录，是因为这样才更有感觉，正所谓“好记性，不如烂笔头”。