{"id":181,"date":"2012-09-29T18:03:52","date_gmt":"2012-09-29T18:03:52","guid":{"rendered":"http:\/\/www.axelirriger.de\/?p=181"},"modified":"2018-09-02T11:06:02","modified_gmt":"2018-09-02T09:06:02","slug":"nebenlaufigkeit-heute-aktoren","status":"publish","type":"post","link":"https:\/\/www.axelirriger.de\/index.php\/2012\/09\/29\/nebenlaufigkeit-heute-aktoren\/","title":{"rendered":"Nebenl\u00e4ufigkeit heute: Aktoren"},"content":{"rendered":"<div class=\"shariff\" data-title=\"Nebenl\u00e4ufigkeit heute: Aktoren\" data-info-url=\"http:\/\/ct.de\/-2467514\" data-backend-url=\"https:\/\/www.axelirriger.de\/wp-content\/plugins\/shariff-sharing\/backend\/index.php\" data-temp=\"\/tmp\" data-ttl=\"60\" data-service=\"gftr\" data-services='[\"googleplus\",\"facebook\",\"twitter\",\"reddit\",\"info\"]' data-image=\"\" data-url=\"https:\/\/www.axelirriger.de\/index.php\/2012\/09\/29\/nebenlaufigkeit-heute-aktoren\/\" data-lang=\"en\" data-theme=\"colored\" data-orientation=\"horizontal\"><\/div><h1>Einleitung<\/h1>\n<p>Der Entwurf von nebenl\u00e4ufigen Anwendungen stellt seit Jahren eine Herausforderung dar, f\u00fcr die es keine einfache L\u00f6sung gibt. Mittlerweile wurden unterschiedliche M\u00f6glichkeiten entwickelt, diesem Problem zu begegnen. Das Aktoren-Modell stellt dabei eine einfache und erprobte M\u00f6glichkeit dar, nebenl\u00e4ufige Algorithmen zu implementieren.<!--more--><\/p>\n<p>Um die Nutzung des Aktoren-Modells zu verdeutlichen, stelle ich in einer Artikel-Serie die Nutzung am Beispiel des <a href=\"http:\/\/akka.io\">Frameworks Akka<\/a> vor, ohne zu stark auf die Theorie dahinter einzugehen! Das Framework Akka implementiert das Aktoren-Modell f\u00fcr die Programmiersprachen Java und Scala und eignet sich sehr gut f\u00fcr die Nutzung in Cloud-Umgebungen.<\/p>\n<h1>\u00dcbersicht \u00fcber die Artikel-Serie<\/h1>\n<p>Die Serie umfasst folgende Artikel:<\/p>\n<ul>\n<li>Nebenl\u00e4ufigkeit heute: Aktoren (dieser Artikel)<\/li>\n<li>Aufbau eines Aktoren-Modells mit Akka (noch nicht ver\u00f6ffentlicht)<\/li>\n<li>Wiederverwendung und Identifikation: Aktor-Instanzen (noch nicht ver\u00f6ffentlicht)<\/li>\n<li>Nachrichten-Persistenz mit Akka (noch nicht ver\u00f6ffentlicht)<\/li>\n<li>Verteilte Systeme mit Akka (noch nicht ver\u00f6ffentlicht)<\/li>\n<\/ul>\n<div>[<strong>Update 1<\/strong>: Warum sich mit Aktoren besch\u00e4ftigen? <a title=\"Nebenl\u00e4ufigkeit heute: Eine \u00dcbersicht\" href=\"http:\/\/www.axelirriger.de\/index.php\/2012\/09\/29\/nebenlufigkeit-heute-eine-bersicht\/\">Eine Begr\u00fcndung gibt es hier<\/a>!]<\/div>\n<div>[<strong>Update 2<\/strong>: Eine sehr kurze \u00dcbersicht habe ich auf der Informatik 2012 zum Thema<a title=\"Elastische Skalierbarkeit f\u00fcr Web-Anwendungen\" href=\"http:\/\/www.axelirriger.de\/2012\/09\/29\/elastische-skalierbarkeit-fur-web-anwendungen\/\"> Elastische Skalierbarkeit von Web-Anwendungen<\/a>&nbsp;gegeben.]<\/div>\n<h1>Das Aktoren-Modell<\/h1>\n<p>Um das Aktoren-Modell besser zu verstehen, gibt es erst einen \u00dcberblick \u00fcber das wesentliche Konzept. Daran anschlie\u00dfend erfolgt die Anwendung auf eine konkrete Fragestellung.<\/p>\n<h2>\u00dcbersicht<\/h2>\n<p>Bei nebenl\u00e4ufiger Programmierung stellen sich folgende Herausforderungen:<\/p>\n<ul>\n<li><strong>Zugriff auf gemeinsame Ressourcen:&nbsp;<\/strong>Dies wird zumeist \u00fcber Sperren (\u201cLocks\u201d) realisiert, um zu gew\u00e4hrleisten, dass zu einer Zeit nur ein Prozess auf eine gemeinsame Ressourcen zugreift.<\/li>\n<li><strong>Synchronisation:<\/strong> Hierbei werden meistens Sprachmittel (\u201csynchronized\u201d-Schl\u00fcsselwort, o.\u00e4.) eingesetzt, um eine Ausf\u00fchrungsreihenfolge zu garantieren<\/li>\n<\/ul>\n<p>Beide Konzepte begrenzen die m\u00f6gliche Parallelit\u00e4t, da f\u00fcr solche Stellen explizit eine sequentielle Verarbeitung erzwungen wird.<\/p>\n<p>Als weiteres Problem existieren <strong>Deadlocks<\/strong>. Dabei handelt es sich um einen Ringschluss, bei dem eine Komponente \u00fcber eine Zwischenstufe auf sich selbst wartet. F\u00fcr dieses Problem gibt es keine einfache L\u00f6sung, au\u00dfer der Simulation und einem bedachten Algorithmus-Design.<\/p>\n<h2>Aktoren als Alternative<\/h2>\n<p>Es gibt jedoch eine L\u00f6sung f\u00fcr diese Problem: das <strong><a href=\"http:\/\/en.wikipedia.org\/wiki\/Actor_model\">Aktoren Modell<\/a><\/strong>. Dabei handelt es sich um ein Modell von <a href=\"http:\/\/de.wikipedia.org\/wiki\/Carl_Hewitt\">Carl Hewitt<\/a>, dass nebenl\u00e4ufige Interaktion explizit beschreibt und formalisiert und damit die Nachteile der klassischen Entwicklung ausgleicht. Die Mitspieler hierbei sind:<\/p>\n<ul>\n<li>die Aktoren, sowie<\/li>\n<li>Nachrichten<\/li>\n<\/ul>\n<p>Die Idee ist nun, jeden eigenst\u00e4ndig lauff\u00e4higen, nebenl\u00e4ufigen Teil des Problems als eigenst\u00e4ndigen Aktor aufzufassen. Die L\u00f6sung des Gesamtproblems ergibt sich durch <strong>Kommunikation<\/strong> der einzelnen Aktoren untereinander. Die Kommunikation erfolgt gerichtet und explizit durch das Senden einer <strong>Nachricht<\/strong> an den betreffenden Aktor. Das ganze l\u00e4sst sich bildlich so darstellen:<\/p>\n<p><a href=\"http:\/\/www.axelirriger.de\/wp-content\/uploads\/2012\/09\/image.png\"><img loading=\"lazy\" decoding=\"async\" style=\"float: none; margin-left: auto; margin-right: auto; border-width: 0px;\" src=\"http:\/\/www.axelirriger.de\/wp-content\/uploads\/2012\/09\/image_thumb.png\" alt=\"image\" width=\"404\" height=\"357\" border=\"0\"><\/a><\/p>\n<p>In obigem Bild schickt <strong>Aktor 1<\/strong> eine Nachricht (\u201cNachricht A\u201d) an <strong>Aktor 2<\/strong>. Dieser bearbeitet die Nachricht und schickt vielleicht eine weitere Nachricht (\u201cNachricht B\u201d) weiter an den n\u00e4chsten Aktor. Das besondere an diesem Vorgehen ist, dass <strong>ein Aktor immer nur eine Nachricht bearbeitet.<\/strong> Dadurch ergibt sich eine geordnete Bearbeitungsreihenfolge. Um sicherzustellen, dass Aktor 2 nicht viele Nachrichten auf einmal erh\u00e4lt und bearbeitet, werden diese durch eine Warteschlage aufgefangen, die durch den Aktor abgearbeitet wird.<\/p>\n<h2>Aktoren in der Praxis<\/h2>\n<p>Es gibt viele Implementierungen von Aktoren, gerade im Kontext hochparalleler und ausfallsicherer Systeme. Die <a href=\"http:\/\/www.erlang.org\/\">Programmiersprache Erlang<\/a> setzt <a href=\"http:\/\/www.gruntz.ch\/papers\/ErlangActors.pdf\">Aktoren explizit ein<\/a>, um Nebenl\u00e4ufigkeit zu realisieren.<\/p>\n<h2>Auswirkungen des Aktoren-Modells<\/h2>\n<p>Von zentraler Bedeutung ist, dass ein Aktor mit seiner Arbeit fertig ist, wenn er<\/p>\n<ul>\n<li>entweder nichts mehr zu tun hat (=am Ende seiner Methode\/Funktion\/Klasse angekommen ist), oder<\/li>\n<li>eine Nachricht an einen anderen Aktor geschickt hat und auf eine Antwort wartet<\/li>\n<\/ul>\n<p>Ein Aktor wartet nicht auf die Antwort eines anderen Aktors, sondern verarbeitet einfach die n\u00e4chste aus seiner Warteschlange! Der Grund daf\u00fcr ist, dass das Aktoren-Modell Synchronisation vermeidet und ein Wartezustand ist eine Form der Synchronisation.<\/p>\n<h1>Aktoren live: Ein einfaches Beispiel<\/h1>\n<p>Das folgende, einfache Problem soll die Probleml\u00f6sung mit Aktoren verdeutlichen:<\/p>\n<ul>\n<li>Es gibt ein Produkt, das aus verschiedenen Bauteilen besteht<\/li>\n<li>Jedes Bauteil hat einen eigenen Preis<\/li>\n<li>der Produktpreis ergibt sich aus der Summe der Bauteilpreise zzgl. einer Montagegeb\u00fchr<\/li>\n<\/ul>\n<p>Um das Problem in Aktoren zu zerlegen, modelliert man als erstes die Abh\u00e4ngigkeiten der Komponenten untereinander. Dies sieht f\u00fcr das Problem wie folgt aus:<\/p>\n<p><a href=\"http:\/\/www.axelirriger.de\/wp-content\/uploads\/2012\/09\/image1.png\"><img loading=\"lazy\" decoding=\"async\" style=\"border-width: 0px;\" src=\"http:\/\/www.axelirriger.de\/wp-content\/uploads\/2012\/09\/image_thumb1.png\" alt=\"image\" width=\"454\" height=\"253\" border=\"0\"><\/a><\/p>\n<p>Dieses Modell l\u00e4sst sich so darstellen, dass das Produkt bei seinen Bauteilen nach den individuellen Preisen \u201cfragt\u201d und, nachdem es alle Preise beisammen hat, den Gesamtpreis errechnet. Das zugeh\u00f6rige Modell kann so aussehen:<\/p>\n<p><a href=\"http:\/\/www.axelirriger.de\/wp-content\/uploads\/2012\/09\/image2.png\"><img loading=\"lazy\" decoding=\"async\" style=\"border-width: 0px;\" src=\"http:\/\/www.axelirriger.de\/wp-content\/uploads\/2012\/09\/image_thumb2.png\" alt=\"image\" width=\"454\" height=\"291\" border=\"0\"><\/a><\/p>\n<p>Hierbei sendet der Produkt-Aktor Nachrichten (\u201cgetPrice\u201d) an alle Bauteile. Anschlie\u00dfend arbeitet er wieder seine Warteschlange ab, bis Antworten eintreffen. Jeder Bauteil-Aktor verarbeitet die Nachricht und sendet seine Antwort an den Produkt-Aktor zur\u00fcck. Entgegen der Darstellung handelt es sich bei der Kommunikation nicht um synchrone Aufrufe, sondern um eine asynchrone Kommunikation.<\/p>\n<p>Damit der Produkt-Aktor den Gesamtpreis berechnen kann, m\u00fcssen folgende Bedingungen erf\u00fcllt sein:<\/p>\n<ul>\n<li>Der Aktor muss wissen, wie viele Nachrichten verschickt wurden<\/li>\n<li>Der Aktor muss wissen, wie viele Antworten zur\u00fcckgekommen sind<\/li>\n<\/ul>\n<p>Die erste Bedingung ist relativ einfach zu realisieren: es werden so viele Nachrichten verschickt, wie es Bauteile gibt. Die zweite Bedingung stellt eine weitere Eigenschaft eines Aktors dar: <strong>ein Aktor speichert und verwaltet seinen Zustand <\/strong>(siehe auch <a href=\"http:\/\/james-iry.blogspot.de\/2009\/04\/state-of-sock-tubes.html\">hier<\/a> (englisch)). Sobald die letzte Nachricht eingetroffen ist, kann die Berechnung durchgef\u00fchrt und abgeschlossen werden. Anschlie\u00dfend kann das Ergebnis zur\u00fcckgegeben , gespeichert , oder anderweitig verarbeitet werden.<\/p>\n<p>[Ein weiteres Beispiel f\u00fcr Aktoren findet sich bei <a href=\"http:\/\/blog.florian-hopf.de\/2012\/08\/getting-rid-of-synchronized-using-akka.html\">Florian Hopf<\/a>.]<\/p>\n<h2>Laufzeit und parallele Anfragen<\/h2>\n<p>Durch die asynchrone Kommunikation zwischen den Aktoren, kann zu Beginn einer Verarbeitung keine Aussage dar\u00fcber getroffen werden, wann diese beendet sein wird. Der Grund hierf\u00fcr ist, dass jeder Aktor seine eigene Warteschlange mit (potenziell) unterschiedlichem F\u00fcllstand besitzt. Eine weitere Schwierigkeit ergibt sich, wenn mehrere Preisberechnungen (quasi) simultan erfolgen sollen. In diesem Falle muss noch eine Statusverfolgung vorgesehen werden, um die einzelnen Anfragen und Antworten auseinander zu halten.<\/p>\n<h1>Zusammenfassung und Ausblick<\/h1>\n<p>Dieser einf\u00fchrender Beitrag hat das Aktoren-Modell vorgestellt und anhand einer Trocken\u00fcbung konkretisiert. In den n\u00e4chsten Beitr\u00e4gen werden wir dieses Modell exemplarisch anhand von Akka, implementieren.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Einleitung Der Entwurf von nebenl\u00e4ufigen Anwendungen stellt seit Jahren eine Herausforderung dar, f\u00fcr die es keine einfache L\u00f6sung gibt. Mittlerweile wurden unterschiedliche M\u00f6glichkeiten entwickelt, diesem Problem zu begegnen. Das Aktoren-Modell stellt dabei eine einfache und erprobte M\u00f6glichkeit dar, nebenl\u00e4ufige Algorithmen zu implementieren.<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"ngg_post_thumbnail":0,"footnotes":""},"categories":[7,8],"tags":[76,77,34,78,79],"class_list":["post-181","post","type-post","status-publish","format-standard","hentry","category-software-entwicklung","category-the-cloud","tag-actor-model","tag-akka","tag-java","tag-multithreading","tag-parallelism"],"_links":{"self":[{"href":"https:\/\/www.axelirriger.de\/index.php\/wp-json\/wp\/v2\/posts\/181","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.axelirriger.de\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.axelirriger.de\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.axelirriger.de\/index.php\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.axelirriger.de\/index.php\/wp-json\/wp\/v2\/comments?post=181"}],"version-history":[{"count":11,"href":"https:\/\/www.axelirriger.de\/index.php\/wp-json\/wp\/v2\/posts\/181\/revisions"}],"predecessor-version":[{"id":665,"href":"https:\/\/www.axelirriger.de\/index.php\/wp-json\/wp\/v2\/posts\/181\/revisions\/665"}],"wp:attachment":[{"href":"https:\/\/www.axelirriger.de\/index.php\/wp-json\/wp\/v2\/media?parent=181"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.axelirriger.de\/index.php\/wp-json\/wp\/v2\/categories?post=181"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.axelirriger.de\/index.php\/wp-json\/wp\/v2\/tags?post=181"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}