Akka中的Scheduler

Actor之间进行通信时,通常都会立即发送消息,然后即刻返回,不会阻塞。但是,AKKA也支持我们对Actor设置Scheduler,用以控制发送消息的次数和时间。

Scheduler由ActorSystem提供,可以对Actor的消息发送进行调度。可以通过ActorContext获得当前的ActorSystem,进而获得Scheduler。如下方法是定期在5秒后执行一次:

import scala.concurrent.ExecutionContext
import scala.concurrent.duration._

import context.dispatcher
context.system.scheduler.scheduleOnce(5 seconds, targetActorRef, RequestMessage)

AKKA还支持消息的定期重复执行,方法为schedule()。例如设置在2秒后,间隔5秒重复执行:

import context.dispatcher
context.system.scheduler.schedule(2 seconds, 5 seconds, targetActorRef, RequestMessage)

如果传入schedule函数的第一个参数为0 seconds,则表示消息会及时发送,然后每隔5秒钟再重复发送。

注意,在上述的两段代码中,调用schedule()或scheduleOnce()方法之前都必须导入context.dispatcher,因为这两个方法都定义了类型为ExecutionContext的隐式参数,如下为AKKA中schedule函数的定义:

  final def schedule(
    initialDelay: FiniteDuration,
    interval: FiniteDuration,
    receiver: ActorRef,
    message: Any)(implicit executor: ExecutionContext,
                  sender: ActorRef = Actor.noSender): Cancellable =
    schedule(initialDelay, interval, new Runnable {
      def run = {
        receiver ! message
        if (receiver.isTerminated)
          throw new SchedulerException("timer active for terminated actor")
      }
    })

如果调用schedule()方法,只要不终止context或者actor,消息就会一直被发送。如果希望指定发送消息的条数,就无能为力了。例如,我希望每5秒钟发送一次消息,一共发送100次,然后终止receiver。期望的调用为:

context.system.scheduler.schedule(0 seconds, 5 seconds, 100, targetActorRef, RequestMessage)

好在AKKA已经将基本的调度工作完成了,我们可以自定义这样的接口,在重用现有schedule()方法的基础上,引入执行次数。为了让接口更加自然,我们可以通过引入隐式转换为Scheduler类增加这个新的方法,实现代码如下:

  implicit class SchedulerWrapper(scheduler: Scheduler) {
    def schedule(initialDelay: FiniteDuration,
                 interval: FiniteDuration,
                 repeatTimes: Int,
                 receiver: ActorRef,
                 message: Any)(implicit executor: ExecutionContext,
                               sender: ActorRef = Actor.noSender): Cancellable = {
      var count = 0
      var repeatScheduler: Option[Cancellable] = None
      repeatScheduler = Some(
        scheduler.schedule(initialDelay, interval) {
          receiver ! message
          count += 1
          if (receiver.isTerminated && count < repeatTimes)
            throw new Exception("timer active for terminated actor")

          if (count >= repeatTimes) {
            repeatScheduler.foreach(_.cancel())
          }
      })
      repeatScheduler.get
    }
  }

一旦发送消息的次数超过指定的repeatTimes,schedule的过程就会被取消。

即使与Actor无关,也可以利用Scheduler来执行一些需要反复重试的工作。例如,在Spark中,AppClient中的ClientActor需要与Master这个Remote Actor通信,从而注册所有的Spark Master。由于注册过程中牵涉到远程通信,可能会因为网络原因导致通信错误,因此需要引入重试的机会。代码实现为:

  private val REGISTRATION_TIMEOUT = 20.seconds
  private val REGISTRATION_RETRIES = 3

   def tryRegisterAllMasters() {
      for (masterAkkaUrl <- masterAkkaUrls) {
        logInfo("Connecting to master " + masterAkkaUrl + "...")
        val actor = context.actorSelection(masterAkkaUrl)
        actor ! RegisterApplication(appDescription)
      }
    }

    def registerWithMaster() {
      tryRegisterAllMasters()
      import context.dispatcher
      var retries = 0
      registrationRetryTimer = Some {
        context.system.scheduler.schedule(REGISTRATION_TIMEOUT, REGISTRATION_TIMEOUT) {
          Utils.tryOrExit {
            retries += 1
            if (registered) {
              registrationRetryTimer.foreach(_.cancel())
            } else if (retries >= REGISTRATION_RETRIES) {
              markDead("All masters are unresponsive! Giving up.")
            } else {
              tryRegisterAllMasters()
            }
          }
        }
      }
    }

tryRegisterAllMasters()方法会通过masterAkkUrl获得remote actor(即Master),然后发送RegisterApplication消息。Master收到该消息后,会进行注册工作,具体代码如下:

    case RegisterApplication(description) => {
      if (state == RecoveryState.STANDBY) {
        // ignore, don't send response
      } else {
        logInfo("Registering app " + description.name)
        val app = createApplication(description, sender)
        registerApplication(app)
        logInfo("Registered app " + description.name + " with ID " + app.id)
        persistenceEngine.addApplication(app)
        sender ! RegisteredApplication(app.id, masterUrl)
        schedule()
      }
    }

Master中的sender实际就是ClientActor,在注册成功后,通过sender发送RegisteredApplication消息。在ClientActor中的实现为:

    override def receiveWithLogging: PartialFunction[Any, Unit] = {
      case RegisteredApplication(appId_, masterUrl) =>
        appId = appId_
        registered = true
        changeMaster(masterUrl)
        listener.connected(appId)
        //其他代码
    }

收到RegisteredApplicaition消息即意味着注册成功,则标志变量registered就设置为true。在结合前面代码中的registerWithMaster()方法。如果registered为true,就会取消。对应代码为:

registrationRetryTimer.foreach(_.cancel())

schedule()返回的类型的类型为Cancellable,因此,registrationRetryTimer类型就为Some[Cancellable]。如果registered为false,就继续尝试去注册,直到注册成功或者重试次数超过指定次数。

2016-12-26 15:4592AKKAScala