spark streaming被压分析

在我们使用spark-streaming处理实时数据时,通常在Dstream端的rdd操作较为耗时,此刻的实时数据还在receiver端不断的store。由于数据的处理不及时,即Processing Time < blockInterval也就造成了数据的积压。此时就需要一种机制来解决receiver端store数据的“速率”。在spark streaming中就是被压(backpressure);

简单使用

开启被压参数

spark.streaming.backpressure.enabled=true

此参数会开启spark streaming内部的被压机制(1.5以上版本),开始后spark streaming会根据当前处理批次的scheduling delays(batch调度延迟时间)和 processing times(batch处理时间)控制receiver端的接受速率,以达到和数据的处理速度一样快。设置的接收速率受spark.streaming.receiver.maxRate参数的影响。

设置初始处理速率

spark.streaming.backpressure.initialRate=xxx

此参数会在receiver接收第一批(first batch)数据时初始化的最大速率,此参数只会在被压参数开启时有效。
设置此参数可以在启动spark streaming程序的瞬间就达到我们期望的最大值,而不是靠被压参数慢慢调整。

设置最小处理速率

spark.streaming.backpressure.pid.minRate=x

此参数在spark streaming中默认值为100.如果我们store的数据为一个集合,那么允许的最小速率就是100集合的数据,此时数据量可能也会很大。所以最好设置一个初始值。比如1.

设置最大处理速率

spark.streaming.receiver.maxRate=xxx

每个receiver接收数据的最大速率,每个dstream最大只能消耗这么多的数据。设置为0或者负数将不做限制。

此参数一般不做设置,除非你的机器上还有其它程序。

被压原理

我们就从receiver端的store方法开始

 /**
   * Store a single item of received data to Spark's memory.
   * These single items will be aggregated together into data blocks before
   * being pushed into Spark's memory.
   */
  def store(dataItem: T) {
    supervisor.pushSingle(dataItem)
  }

store方法中的supervisor对象类型为ReceiverSupervisorImpl 所以直接进入ReceiverSupervisorImpl实现类中

  /** Push a single record of received data into block generator. */
  def pushSingle(data: Any) {
    defaultBlockGenerator.addData(data)
  }

defaultBlockGeneratoraddData方法内容为

  /**
   * Push a single data item into the buffer.
   */
  def addData(data: Any): Unit = {
    if (state == Active) {
     //等待push
      waitToPush()
      synchronized {
        if (state == Active) {
          currentBuffer += data
        } else {
          throw new SparkException(
            "Cannot add data as BlockGenerator has not been started or has been stopped")
        }
      }
    } else {
      throw new SparkException(
        "Cannot add data as BlockGenerator has not been started or has been stopped")
    }
  }

被压机制的实现就在waitToPush方法中。点进去查看


  private val maxRateLimit = conf.getLong("spark.streaming.receiver.maxRate", Long.MaxValue)
  private lazy val rateLimiter = GuavaRateLimiter.create(getInitialRateLimit().toDouble)


  def waitToPush() {
    //从令牌桶中取令牌
    rateLimiter.acquire()
  }

  private[receiver] def updateRate(newRate: Long): Unit =
    if (newRate > 0) {
      if (maxRateLimit > 0) {
        rateLimiter.setRate(newRate.min(maxRateLimit))
      } else {
        rateLimiter.setRate(newRate)
      }
    }

  private def getInitialRateLimit(): Long = {
    math.min(conf.getLong("spark.streaming.backpressure.initialRate", maxRateLimit), maxRateLimit)
  }

仔细查看rateLimiter对象,我们会方向这个对象就是使用Guava的开源工具包RateLimiter实现的,如果想了解rateLimiter原理的,可以google搜索,一大堆。
有人可能说rateLimitersemphore很像,其实semphore是控制并发,而rateLimiter控制速率,尽管速率和并发很像。(具体参考:https://en.wikipedia.org/wiki/Little’s_law)

getInitialRateLimit方法我们可以看出rateLimiter的初始值为spark.streaming.backpressure.initialRate,如果没有设置默认为最大速率spark.streaming.receiver.maxRate
GuavaRateLimiter.create(getInitialRateLimit().toDouble)方法会创建一个每秒令牌数为初始设置的令牌桶。acquire方法就是从桶中取令牌。

细心的你可能发现还有个updateRate方法,此方法会更新每秒能获得的最大令牌数。

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 猿与汪的秘密 设计师:上身试试 返回首页