Sleeping Schauspieler?

Question

Was ist der beste Weg, einen Schauspieler Schlaf haben? Ich habe Schauspieler als Agenten aufgebaut, die unterschiedlichen Teile einer Datenbank beibehalten möchten (einschließlich Daten aus externen Quellen erhalten). Aus einer Reihe von Gründen (einschließlich nicht auf die Datenbank oder Kommunikation und die allgemeine Belastung Probleme Überlastung), möchte ich die Darsteller zwischen jeder Operation schlafen. Ich bin an so etwas wie 10 Schauspieler Objekte suchen.

Die Schauspieler werden so ziemlich unendlich laufen, da es immer neue Daten in der kommenden sein wird, oder in einem Tisch sitzen warten auf andere Teile der Datenbank weitergegeben werden usw. Die Idee ist für die Datenbank so vollständig wie möglich zu sein, an jedem beliebigen Punkt in der Zeit.

Ich konnte dies mit einer Endlos-Schleife und ein Schlaf am Ende jeder Schleife, sondern nach

War es hilfreich?

einreichen

Lösung

Es gibt keine Notwendigkeit explizit einen Schauspieler verursachen schlafen. Mit loop und react für jeden Akteur bedeutet, dass der zugrunde liegende Thread-Pool wartenden Threads hat, während es keine Nachrichten für die Schauspieler zu verarbeiten

Im Fall, dass Sie auf Zeitplan Veranstaltungen für Ihre Akteure zu verarbeiten, das ist ziemlich einfach, einen Single-Thread-Scheduler aus dem java.util.concurrent Dienstprogramme:

object Scheduler {
  import java.util.concurrent.Executors
  import scala.compat.Platform
  import java.util.concurrent.TimeUnit
  private lazy val sched = Executors.newSingleThreadScheduledExecutor();
  def schedule(f: => Unit, time: Long) {
    sched.schedule(new Runnable {
      def run = f
    }, time , TimeUnit.MILLISECONDS);
  }
}

Sie können diese erweitern periodische Aufgaben zu übernehmen und es könnte daher verwendet werden:

val execTime = //...  
Scheduler.schedule( { Actor.actor { target ! message }; () }, execTime)

Ihr Ziel Schauspieler wird dann einfach braucht eine geeignete react Schleife zu implementieren, um die gegebene Nachricht zu verarbeiten. Es besteht keine Notwendigkeit für Sie jeden Schauspieler Schlaf haben.

Answer 1

Es gibt keine Notwendigkeit explizit einen Schauspieler verursachen schlafen. Mit loop und react für jeden Akteur bedeutet, dass der zugrunde liegende Thread-Pool wartenden Threads hat, während es keine Nachrichten für die Schauspieler zu verarbeiten

Im Fall, dass Sie auf Zeitplan Veranstaltungen für Ihre Akteure zu verarbeiten, das ist ziemlich einfach, einen Single-Thread-Scheduler aus dem java.util.concurrent Dienstprogramme:

object Scheduler {
  import java.util.concurrent.Executors
  import scala.compat.Platform
  import java.util.concurrent.TimeUnit
  private lazy val sched = Executors.newSingleThreadScheduledExecutor();
  def schedule(f: => Unit, time: Long) {
    sched.schedule(new Runnable {
      def run = f
    }, time , TimeUnit.MILLISECONDS);
  }
}

Sie können diese erweitern periodische Aufgaben zu übernehmen und es könnte daher verwendet werden:

val execTime = //...  
Scheduler.schedule( { Actor.actor { target ! message }; () }, execTime)

Ihr Ziel Schauspieler wird dann einfach braucht eine geeignete react Schleife zu implementieren, um die gegebene Nachricht zu verarbeiten. Es besteht keine Notwendigkeit für Sie jeden Schauspieler Schlaf haben.

Answer 2

Es war ein guter Punkt zu Erlang in der ersten Antwort, aber es scheint verschwunden. Sie können ganz einfach mit Scala Schauspielern den gleichen Erlang-like Trick. Z.B. Lassen Sie uns einen Scheduler erstellen, die keine Threads nicht verwendet:

import actors.{Actor,TIMEOUT}

def scheduler(time: Long)(f: => Unit) = {
  def fixedRateLoop {
    Actor.reactWithin(time) {
      case TIMEOUT => f; fixedRateLoop
      case 'stop => 
    }
  }
  Actor.actor(fixedRateLoop)
}

Und wir testen es (ich habe es richtig in Scala REPL) einen Test-Client-Schauspieler mit:

case class Ping(t: Long)

import Actor._
val test = actor { loop {
  receiveWithin(3000) {
    case Ping(t) => println(t/1000)
    case TIMEOUT => println("TIMEOUT")
    case 'stop => exit
  }
} }

Führen Sie den Scheduler:

import compat.Platform.currentTime
val sched = scheduler(2000) { test ! Ping(currentTime) }

und Sie werden sehen, so etwas wie dieses

scala> 1249383399
1249383401
1249383403
1249383405
1249383407

Das bedeutet, unsere Scheduler eine Nachricht alle 2 Sekunden wie erwartet sendet. Lassen Sie uns den Scheduler stoppen:

sched ! 'stop

Sie den Test-Client beginnt Timeouts zu berichten:

scala> TIMEOUT
TIMEOUT
TIMEOUT

stoppen sie auch:

test ! 'stop

Answer 3

ActorPing (Apache License) von Lift-util hat Zeitplan und scheduleAtFixedRate Quelle: ActorPing.scala

Von scaladoc:

  

Die ActorPing Objekt Pläne ein Schauspieler Ping-ed mit einer bestimmten Nachricht in bestimmten Abständen zu sein. Die Zeitplan-Methoden geben ein ScheduledFuture Objekt, das bei Bedarf rückgängig gemacht werden kann

Answer 4

Es sind leider zwei Fehler in der Antwort von oxbow_lakes.

Eine davon ist eine einfache Erklärung Fehler (lange Zeit gegen die Zeit: Long)., Aber der zweite ist etwas subtiler

oxbow_lakes deklariert als

laufen

def run = actors.Scheduler.execute(f) 

Dies führt jedoch zu Nachrichten von Zeit zu Zeit zu verschwinden. Das heißt: sie geplant sind, aber nie bekommen senden. Deklarieren Lauf als

def run = f

regelte es für mich. Es ist die genaue Art und Weise in der ActorPing von Lift-util getan.

Der ganze Scheduler Code wird:

object Scheduler {
    private lazy val sched = Executors.newSingleThreadedScheduledExecutor();
    def schedule(f: => Unit, time: Long) {
        sched.schedule(new Runnable {
          def run = f
        }, time - Platform.currentTime, TimeUnit.MILLISECONDS);
    }
}

Ich habe versucht, Post bearbeiten oxbow_lakes, konnte es aber nicht (gebrochen?) Speichern, ich Rechte nicht haben, Stellung zu nehmen, noch. Daher ist eine neue Stelle.