Wie unterscheidet sich die Implementierung mehrerer Akteure in Scala?

Mit der Veröffentlichung von Scala 2.9.0 wurde auch der Typesafe Stack angekündigt, der die Scala-Sprache mit dem Akka-Framework kombiniert. Obwohl Scala Schauspieler in seiner Standardbibliothek hat, verwendet Akka jetzt eine eigene Implementierung. Und wenn wir nach anderen Implementierungen suchen, werden wir auch feststellen, dass Lift und Scalaz auch Implementierungen haben!

Was ist der Unterschied zwischen diesen Implementierungen?

Diese Antwort ist nicht wirklich meine. Es wurde von Viktor Klang (von Akka) mit Hilfe von David Pollak (von Lift), Jason Zaugg (von Scalaz) und Philipp Haller (von Scala Actors) produziert.

Alles, was ich hier mache, ist das Formatieren (was einfacher wäre, wenn Stack Overflow Tabellen unterstützt).

Es gibt einige Stellen, die ich später besetzen werde, wenn ich mehr Zeit habe.

Grundsätze für die Gestaltung

• Scalaz Schauspieler

  Minimale Komplexität. Maximale Allgemeinheit, Modularität und Erweiterbarkeit.

• Schauspieler anheben

  Minimale Komplexität, Garbage Collection durch JVM, anstatt sich um einen expliziten Lebenszyklus zu sorgen, Fehlerbehandlungsverhalten im Einklang mit anderen Scala- und Java-Programmen, geringer / geringer Speicherbedarf, Postfach, statisch ähnlich wie bei Scala Actors und Erlang-Akteuren, hohe Leistung.

• Scala-Schauspieler

  Stellen Sie das vollständige Erlang-Darstellermodell in Scala bereit, mit geringem Gewicht und geringem Speicherbedarf.

• Akka Schauspieler

  Einfach und transparent verteilbar, leistungsstark, leicht und äußerst anpassungsfähig.

Versionierung

                    Scalaz Actors Lift Actors Scala Actors Akka Actors
Aktuelle stabile ver. 5 2.1 2.9.0 0.10
Minimum Scala ver. 2.8 2.7.7 2.8
Minimum Java ver. 1,5 1,5 1,6

Unterstützung für Schauspieler-Modelle

                    Scalaz Actors Lift Actors Scala Actors Akka Actors
Neue Schauspieler hervorbringen Ja Ja Ja Ja
innerhalb des Schauspielers
Nachrichten senden an Ja Ja Ja Ja
bekannter Schauspieler 
Verhalten ändern Akteure sind Ja Ja: verschachtelt Ja:
für die nächste Nachricht unveränderlich reagieren / empfangen werden / nicht werden
Aufsicht nicht vorgesehen Nein Schauspieler: Ja, Ja
(link / trapExit) Reaktor: Nein

Grad der staatlichen Isolation

Wenn der Benutzer öffentliche Methoden für seine Akteure definiert, können diese von außen aufgerufen werden?

• Scalaz Schauspieler: n / a. Schauspieler ist ein versiegeltes Merkmal.
• Lift Actors: Ja
• Scala-Schauspieler: Ja
• Akka-Schauspieler: Nein, die Schauspielerinstanz ist hinter einem ActorRef geschützt.

Schauspielertyp

• Scalaz Schauspieler: Actor[A] extends A => ()
• Lift Actors : LiftActor,SpecializeLiftActor[T]
• Scala Schauspieler: Reactor[T],Actor extends Reactor[Any]
• Akka Schauspieler: Actor[Any]

Actor Lifecycle Management

                    Scalaz Actors Lift Actors Scala Actors Akka Actors
Manueller Start Nein Nein Ja Ja
Manueller Stopp Nein Nein Nein Ja
Neustart bei Fehler n / a Ja Ja Konfigurierbar pro Akteursinstanz
Starten Sie die Semantik neu. N / a Schauspieler erneut ausführen. Stellen Sie den Akteur wieder in den stabilen Zustand, indem Sie ihn neu zuweisen und
                                                    Verhalten werfen die alte Instanz weg
Starten Sie die Konfigurierbarkeit n / an / a X-mal, X-mal innerhalb der Y-Zeit neu
Lebenszyklus-Hooks bereitgestellt Kein Lebenszyklus-Act preStart, postStop, preRestart, postRestart

Nachrichtensende-Modi

                    Scalaz Actors Lift Actors Scala Actors Akka Actors
Feuer vergessen a! Nachricht Schauspieler! msg Schauspieler! msg SchauspielerRef! Nachricht
                    eine Nachricht)
Senden-Empfangen-Antworten (siehe 1) Schauspieler !? msg Schauspieler !? msg SchauspielerRef !! Nachricht
                                    Darsteller !! Nachricht
Send-Receive-Future (siehe 2) Schauspieler !! msg SchauspielerRef !!! Nachricht
Versprechungsergebnis senden (Nachricht). future.onComplete (f => to! f.result)
Zukunft zu (Schauspieler)
Komponieren Sie Schauspieler mit Schauspieler-Comap f Nein Nein Nein
Funktion (siehe 3)

(1) Jede Funktion f wird zu einem solchen Akteur:

val a: Msg => Promise[Rep] = f.promise
val reply: Rep = a(msg).get

(2) Jede Funktion f wird zu einem solchen Akteur:

val a = f.promise
val replyFuture = a(message)

(3) Kontravarianter Funktor : actor comap f. Auch Kleisli Komposition in Promise.

Nachrichtenantwortmodi

TBD

                    Scalaz Actors Lift Actors Scala Actors Akka Actors
Antwort an Absender in Nachricht
Antwort auf Nachricht

Nachrichtenverarbeitung

Unterstützt verschachtelte Empfänge?

• Scalaz Schauspieler: -
• Lift Actors: Ja (mit ein wenig Handcodierung).
• Scala-Akteure: Ja, sowohl threadbasiertes Empfangen als auch ereignisbasiertes Reagieren.
• Akka-Akteure: Nein, Verschachtelungsempfänge können im Laufe der Zeit zu Speicherverlusten und Leistungseinbußen führen.

Mechanismus zur Ausführung von Nachrichten

TBD

                    Scalaz Actors Lift Actors Scala Actors Akka Actors
Name für den Ausführungsmechanismus
Ausführungsmechanismus ist
konfigurierbar
Ausführungsmechanismus kann sein
pro Schauspieler angegeben
Lebenszyklus des Ausführungsmechanismus
muss explizit verwaltet werden
Thread-pro-Schauspieler-Ausführung
Mechanismus
Ereignisgesteuerter Ausführungsmechanismus
Postfachtyp
Unterstützt vorübergehende Postfächer
Unterstützt dauerhafte Postfächer

Distribution / Remote Actors

                    Scalaz Actors Lift Actors Scala Actors Akka Actors
Transparente Fernbedienung n / a Nein Ja Ja
Schauspieler
Transportprotokoll n / an / a Java Akka Remote Protocol
                                                    Serialisierung (Protobuf über TCP)
                                                    auf TCP
Dynamisches Clustering n / an / an / a Im kommerziellen Angebot

Howtos

TBD

                    Scalaz Actors Lift Actors Scala Actors Akka Actors
Definieren Sie einen Schauspieler
Erstellen Sie eine Akteurinstanz
Starten Sie eine Schauspielerinstanz
Stoppen Sie eine Schauspielerinstanz

• scala.actors war der erste ernsthafte Versuch, die Parallelität im Erlang-Stil in Scala zu implementieren, der andere Bibliotheksdesigner dazu inspiriert hat, bessere (in einigen Fällen) und leistungsfähigere Implementierungen vorzunehmen . Das größte Problem (zumindest für mich) ist, dass scala.actors im Gegensatz zu Erlang-Prozessen, ergänzt durch OTP (das das Erstellen fehlertoleranter Systeme ermöglicht), nur eine gute Grundlage bieten, eine Reihe stabiler Grundelemente , die zum Erstellen verwendet werden müssen ein übergeordnetes Framework - am Ende des Tages müssen Sie Ihre eigenen Vorgesetzten, Kataloge von Akteuren, endlichen Zustandsmaschinen usw. über die Akteure schreiben.

• Und hier kommt Akka zur Rettung und bietet einen umfassenden Stack für die akteurbasierte Entwicklung: idiomatischere Akteure, eine Reihe von Abstraktionen auf hoher Ebene für die Koordination (Load Balancer, Akteurspools usw.) und den Aufbau fehlertoleranter Systeme (Supervisors) , portiert von OTP usw.), einfach konfigurierbare Scheduler (Dispatcher) und so weiter. Tut mir leid, wenn ich unhöflich klinge, aber ich denke, es wird keine Zusammenführung in 2.9.0+ geben - ich würde eher erwarten, dass Akka- Schauspieler die stdlib-Implementierung schrittweise ersetzen.

• Scalaz . Normalerweise habe ich diese Bibliothek in der Liste der Abhängigkeiten aller meiner Projekte, und wenn ich aus irgendeinem Grund Akka nicht verwenden kann, speichern nicht blockierende Scalaz-Versprechen (mit all der Güte, wie sequence) in Kombination mit den Standarddarstellern die Tag. Ich habe Scalaz- Schauspieler jedoch nie als Ersatz für scala.actors oder Akka verwendet .

Schauspieler: Scala 2.10 gegen Akka 2.3 gegen Lift 2.6 gegen Scalaz 7.1

Prüfregeln und Ergebnisse für die durchschnittliche Latenzzeit und Durchsatz auf JVM 1.8.0_x.