Planen einer Aufgabe auf eine Feste Zeit des Tages mit Akka

Ich bin ein Anfänger mit Akka. Ich brauche eine Aufgabe planen, jeden Tag zu einem festen Zeitpunkt des Tages, sagen wir 8 UHR. Was ich weiß, wie zu tun ist, planen einer Aufgabe periodisch, zum Beispiel

import akka.util.duration._

scheduler.schedule(0 seconds, 10 minutes) {
  doSomething()
}

Was ist die einfachste Möglichkeit zum planen von Aufgaben zu festen Zeiten des Tages in Akka?

Eine kleine Klammer

Ist es einfach zu tun, was ich will nur mit dieser Funktion. Ein Spielzeug Umsetzung Aussehen würde wie

scheduler.schedule(0 seconds, 24 hours) {
  val now = computeTimeOfDay()
  val delay = desiredTime - now

  scheduler.scheduleOnce(delay) {
    doSomething()
  }
}

Es ist nicht schwer, aber ich führte eine kleine race-Bedingung. In der Tat, betrachten Sie, was passiert, wenn ich starten kurz vor 8 UHR. Die externe Schließung wird gestartet, aber durch die Zeit, die ich berechnen delay wir können nach 8 Uhr. Dies bedeutet, dass der interne Verschluss - execute-rechten Weg - verschoben auf morgen, und damit das überspringen der Ausführung für einen Tag.

Gibt es Möglichkeiten, dieses Problem zu beheben race-Bedingung: für das Beispiel, ich könnte führen Sie die Prüfung alle 12 Stunden, und statt der Terminierung die Aufgabe sofort, indem er Sie an einen Schauspieler, nicht annehmen mehr als eine Aufgabe zu einer Zeit.

Aber wahrscheinlich, diese bereits im Akka oder einige extension.

InformationsquelleAutor der Frage Andrea | 2012-12-04

  1. 6

    Write once, run everyday

    val GatherStatisticsPeriod = 24 hours

private[this] val scheduled = new AtomicBoolean(false)

def calcBeforeMidnight: Duration = { 
  //TODO implement 
} 

def preRestart(reason: Throwable, message: Option[Any]) {
  self ! GatherStatisticsScheduled(scheduled.get)
  super.preRestart(reason, message)
}

def schedule(period: Duration, who: ActorRef) = 
  ServerRoot.actorSystem.scheduler
    .scheduleOnce(period)(who ! GatherStatisticsTick)

def receive = {

  case StartServer(nodeName) => 
    sender ! ServerStarted(nodeName)
    if (scheduled.compareAndSet(false, true)) 
      schedule(calcBeforeMidnight, self)

  case GatherStatisticsTick =>
    stats.update
    scheduled.set(true)
    schedule(GatherStatisticsPeriod, self) 

  case GatherStatisticsScheduled(isScheduled) =>
    if (isScheduled && scheduled.compareAndSet(false, isScheduled))
      schedule(calcBeforeMidnight, self)

}

    Ich glaube, dass die Akka - scheduler verarbeitet neu gestartet wird intern die eine oder andere Weise. Ich verwendete nicht-persistente Weise senden einer Nachricht an sich selbst eigentlich keine Feste Garantie für die Lieferung. Auch Zecken können variieren, so GatherStatisticsPeriod könnte eine Funktion sein.

    InformationsquelleAutor der Antwort idonnie

  2. 3

    Diese Art von scheduling in Akka, müssten Sie Rollen Sie Ihre eigenen oder vielleicht mit Quarz, entweder durch Akka Camel oder diese Prototyp Quarz für akka.

    Wenn Sie nicht brauchen etwas Phantasie und extrem genau, dann würde ich berechnen Sie die Verzögerung, um den gewünschten ersten Zeit und benutzen Sie es als start-Verzögerung für den Zeitplan nennen, und Vertrauen Sie dem Intervall.

    InformationsquelleAutor der Antwort Björn Antonsson

  3. 2

    Lassen Sie uns sagen, Sie wollen führen Sie Ihre Aufgabe jeden Tag um 13 Uhr.

    import scala.concurrent.duration._
import java.time.LocalTime

val interval = 24.hours
val delay = {
  val time = LocalTime.of(13, 0).toSecondOfDay
  val now = LocalTime.now().toSecondOfDay
  val fullDay = 60 * 60 * 24
  val difference = time - now
  if (difference < 0) {
    fullDay + difference
  } else {
    time - now
  }
}.seconds

system.scheduler.schedule(delay, interval)(doSomething())

    Denken Sie auch daran, dass die server-Zeitzone kann sich von Ihnen unterscheiden.

    InformationsquelleAutor der Antwort Pavel Khamutou

  4. 0

    Nur ein weiterer Weg, um es zu erreichen, können Sie diese über das Akka Streams von tickt eine Nachricht und filtern auf Zeit.

    Source
  .tick(0.seconds, 2.seconds, "hello") //emits "hello" every two seconds
  .filter(_ => {
    val now = LocalDateTime.now.getSecond
    now > 20 && now < 30 //will let through only if the timing is right.
  })
  .runForeach(n => println("final sink received " + n))

    InformationsquelleAutor der Antwort ticofab

Schreibe einen Kommentar