Thorben Meier

Transkript

1 F# Thorben Meier Einleitung F# ist eine Multi-Paradigmen-Programmiersprache, die neben funktionalen auch imperative und objektorientierte Sprachelemente enthält. Ihre größten Einflüsse kommen aus der funktionalen und imperativen Programmiersprache ML und insbesondere deren objektorientierter Erweiterung Ocaml (Objective Categorical Abstract Machine Language) sowie aus C# in Hinblick auf die Objektorientierung. F# entstand 2005 aus einem Forschungsprojekt von Don Syme bei,,microsoft Research. Seit Visual Studio 2010 wird F# offiziell als.net-sprache unterstützt und von der Microsoft Entwicklungsabteilung gepflegt. 2 Übersicht Sprachelemente 2.1 Allgemein In F# gibt es keine echten Variablen sondern lediglich Funktionen mit gleichem Rückgabewert. Solche werden mit dem let-operator definiert. F# ist streng typisiert und nutzt Typinferenz, sodass Programmierer die Datentypen nicht explizit angeben müssen. l e t pi = Listing 1: let Hierbei handelt es sich demnach nicht um eine Variablenzuweisung, sondern eine Funktionsdefinition, weswegen folgende Anweisung nicht kompiliert werden kann. l e t pi = l e t pi = 3 Listing 2: let Möchte man ein ähnliches Verhalten nutzen, wie man es von Variablen gewohnt ist, muss man dies beim ersten Deklarieren kenntlich machen. l e t mutable x = 0 x < 5 p r i n t f n %i x // g i b t 5 aus Listing 3: let Auch das Referenzieren von Variablen ist möglich. 1

2 l e t x = r e f 0 // x h a e l t e i n e Referenz auf einen I n t e g e r x := 5 // 5 wird x zugewiesen p r i n t f n %i! x // mit! wird d i e Referenz d e r e f e r e n z i e r t Listing 4: let Gewöhnliche Funktionen und Funktionen höherer Ordnung (,,Currying ) werden auch mit let definiert. // Typinferenz : Fuer a und b werden f l o a t s erwartet l e t d u r c h s c h n i t t a b = ( a + b ) / 2. 0 l e t quadrat x = x x l e t zwei mal f x = f ( f x ) // Aufruf z.b. : zwei mal quadrat 5 Listing 5: let Rekursive Funktionen tragen das Schlüsselwort rec. Außerdem bietet F# das für funktionale Sprachen übliche,,pattern Matching. l e t rec f a k u l t a e t n = match n with 0 > 1 > n f a k u l t a e t ( n 1) Listing 6: let rec Elemente wie Lambda-Ausdrücke,,,List Comprehension, Monaden (in F# computation expressions) und,,closures als Möglichkeit für Kapselung sind in F# ebenfalls enthalten. 2.2 Objektorientierung Wie bereits erwähnt, bietet F# auch an, objektorientiert zu arbeiten und dabei Klassen zu definieren. Mit dem Schlüsselwort type definiert man eine Klasse. Eine Klasse ist also ein abstrakter Datentyp (vgl. type in Haskell). type Konto (nummer : int, b e s i t z e r : s t r i n g ) = l e t mutable guthaben = 0 // I n s t a n z v a r i a b l e n member x. Nummer = nummer member x. B e s i t z e r = b e s i t z e r member x. Guthaben = guthaben end // Instanzmethoden member x. Einzahlen ( betrag ) = guthaben < guthaben + betrag member x. Auszahlen ( betrag ) = guthaben < guthaben betrag Listing 7: Klassen Neue Objekte und weitere Funktionen, die mit Objekten der neuen Klasse arbeiten, werden dann wie folgt definiert. l e t homer = new Konto (12345, Homer ) l e t marge = new Konto (67890, Marge ) 2

3 l e t ueberweisen betrag ( q u e l l e : Konto ) ( z i e l : Konto ) = q u e l l e. Auszahlen betrag z i e l. Einzahlen betrag l e t kontoinfo ( x : Konto ) = p r i n t f n Nummer : %i, B e s i t z e r : %s, Guthaben : %i \ x. Nummer x. B e s i t z e r x. Guthaben Listing 8: Erzeugen von Objekten & Methoden 3 Nebenläufigkeit 3.1 Nebenläufigkeit mit.net-bibliotheken In F# stehen die klassischen Mechanismen zum Erzeugen, Starten usw. von Threads durch die Einbindung der.net-bibliothek System.Threading jederzeit zur Verfügung. Dazu gehören auch die klassischen Methoden zum Synchronisieren von Threads (z.b. Semaphore) und das Sperren von Ressourcen. Bei diesem Verfahren obliegt es natürlich immer dem Programmierer, fehlerfrei zu programmieren, wie folgender Deadlock zeigt. l e t threada = new Thread ( fun ( ) > p r i n t f n ThreadA g e s t a r t e t l o c k resa ( fun ( ) > p r i n t f n Ressource A g e s p e r r t Thread. Sleep (100) // Tu etwas mit A l o c k stateb ( fun ( ) > p r i n t f n Ressource B g e s p e r r t ) ) p r i n t f n ThreadA f e r t i g ) l e t threadb = new Thread ( fun ( ) > p r i n t f n ThreadB g e s t a r t e t l o c k resb ( fun ( ) > p r i n t f n Ressource B g e s p e r r t Thread. Sleep (100) // Tu etwas mit B l o c k statea ( fun ( ) > p r i n t f n Ressource A g e s p e r r t ) ) p r i n t f n ThreadB f e r t i g ) threada. S t a r t ( ) threadb. S t a r t ( ) threada. Join ( ) threadb. Join ( ) Listing 9: Threads & Locks Die.NET-Runtime verfügt neben den klassischen Möglichkeiten über einen sog. Threadpool. In Abhängigkeit von der Maschine wird für jeden Prozess, der den Threadpool verwendet, ein statistisches Threadpool-Objekt der Klasse System.Threading.ThreadPool erzeugt, in dem von Anfang an mehrere Threads auf Aufgaben warten. Der Vorteil besteht darin, dass Threads nicht für jede parallele Berechnung unter einem aufwändig Kontextwechsel erzeugt werden müssen, sondern permanent zur Verfügung stehen und völlig eigenständig Aufgaben aus einer Warteschlange nehmen und ihre Ergebnisse als,,callbacks in einer weiteren Warteschlange ablegen. Für schwergewichtige Aufgaben, wie Benutzeroberflächen, bieten sich per Hand erzeugte Threads jedoch mehr an, da man über diesen expliziten Thread jederzeit volle Kontrolle hat, was bei Threads aus dem Threadpool nicht 3

4 möglich ist, wie z.b. das Abbrechen oder das einfache Abfragen mit Thread.Join(), ob der Thread fertig ist. 3.2 Asynchrone Workflows Asynchrone Workflows sind speziell in F# das Mittel für Parallelität. Sie geben dem Programmierer die Möglichkeit einen,,single-threaded Code mit minimalen Änderungen in einen,,multi-threaded Code zu ändern, indem man um den eigentlichen Code einen sogenannten async-block baut und der Rest von Kompiler bzw. der Laufzeitumgebung übernommen wird. Um zu verstehen, was passiert, wenn man Code in einem async-block ausführt, betrachten wir folgendes Beispiel. l e t task1 = async { r eturn 10+10} l e t task2 = async { r eturn 20+20} Async. Run ( Async. P a r a l l e l [ task1 ; task2 ] ) Listing 10: async Die Anweisung async {return 10+10} erzeugt ein Objekt des Typs Async<int>. Dieses Objekt stellt die asynchron durchzuführende Berechnung da. Die Anweisung Async.Parallel [task1; task2] fügt die beiden Objekte der Tasks task1 und task2 zu einem Objekt des Typs Async<int[]> zusammen, indem die beiden Tasks task1 und task2 innerhalb einer Monade (computation expression) als Aufträge in die Warteschlange des Threadpools gelegt werden. Die Anweisung Async.Run stößt nun den zusammengesetzten Task an, d.h.,,startet die Threads im Threadpool, wobei der Rückgabewert das Array [ 20; 40 ] als Callback aus dem Threadpool geliefert wird. Beginnen wir mit parallelen CPU Tasks als erstes größeres Beispiel. l e t rec f i b x = i f x <= 2 then 1 else f i b ( x 1) + f i b ( x 2) l e t f i b s = Async. P a r a l l e l [ f o r i in > async { return f i b ( i ) } ] > Async. RunSynchronously Listing 11: parallele CPU Tasks Hier werden parallel (und unabhängig von einander) die Fibonacci-Zahlen berechnet. Mit Async.RunSynchronously wird die gesamte asynchrone Berechung gestartet und es wird synchron auf das Ergebnis gewartet. Betrachten wir als zweites etwas größeres Beispiel das asynchrone Abrufen von Webseiten, also von asynchronen I/O Operationen. l e t asynchttp u r l = async { // Erzeuge Anfrage Objekt l e t req = WebRequest. Create ( u r l ) // Warte a u f Antwort, asynchron l e t! resp = req. AsyncGetResponse ( ) // Hol den Stream der Antwort und l i e s s ihn use stream = resp. GetResponseStream ( ) 4

5 use reader = new System. IO. StreamReader ( stream ) } // L i e s s den gesamten Stream, synchron return r eader. ReadToEnd ( ) Listing 12: asynchroner Webaufruf In der gezeigten Implementierung wird der Thread in dem Aufruf von AsyncGetResponse() pausiert bzw. suspended. Die Magie hinter asynchronen I/O Operationen liegt in dem let!-operator. Man kann sich den Operator etwa wie folgt vorstellen:,,führe die Anweisung aus und warte auf das Ergebnis. Falls nötig (und bei Webaufrufen nahezu immer), pausiere den Thread und gib ihn im Threadpool wieder frei. Sobald die Antwort ankommt, führe die ausstehenden Anweisungen als einen,,callback aus. Der use bzw. use!-operator ist mit let zu vergleichen. Der Unterschied liegt darin, dass use die gebundenen Objekte mit dem Ende des Gültigkeitsbereichs wieder freigibt. Werfen wir nun noch einen Blick auf die Kombination von parallelen CPU Tasks und asynchronen I/O Operationen. l e t asynchttp u r l = async { l e t req = WebRequest. Create ( u r l ) use! resp = req. AsyncGetResponse ( ) use stream = resp. GetResponseStream ( ) use reader = new StreamReader ( stream ) return r eader. ReadToEnd ( ) } l e t s i t e s = [ http : / /www. bing. com ; http : / /www. g o o gle. com ; http : / /www. yahoo. com ; http : / /www. search. com ] l e t g e t S i t e s = Async. P a r a l l e l [ f o r s i t e in s i t e s > asynchttp s i t e ] > Async. RunSynchronously Listing 13: paralleler asynchroner Webaufruf Wir sehen hiermit, dass wir auch parallel mehrere asynchrone I/O Operationen ausführen können, indem für jede Webseite mittels Async.Parallel ein Thread aus dem Threadpool genommen wird. Beim Warten auf req.asyncgetresponse() wird der Thread im Threadpool wieder freigegeben. Sobald die Antwort der Webseite ankommt wird mit einem,,callback die Ausführung fortgesetzt, indem wieder ein Thread (muss nicht der selbe sein) aus dem Threadpool genommen wird. Mit Async.RunSynchronously starten wir wiederum die ganze Berechnung und warten synchron auf das Ergebnis. Das Limit für solche Ausführungen liegt einzig und allein an der Rechenleistung der Maschine und kann bei genügend Rechenleistung bei mehreren Tausend liegen. 3.3,,Message Passing mit MailboxProcessor Bisher haben wir gesehen, wie man einfachen asynchronen,,,multi-threaded Code schreibt. Was wir bisher noch nicht berücksichtigt haben, ist die Interprozesskommunikation, mit der verschiedenene parallel ausgeführte Prozesse bzw. Tasks miteinander über Nachrichten kommunizieren können. Das Prinzip nennt sich,,message passing und ist besonders durch die Programmiersprache Erlang bekannt. 5

6 In F# funktioniert das Prinzip des,,message passing über den MailboxProcessor, den man sich in der Tat wie ein Postfach vorstellen kann. Es können Nachrichten gesendet und empfangen werden. Wie das funktioniert, zeigt folgendes einfaches Beispiel. l e t agent = MailboxProcessor. S t a r t ( fun inbox > async { l e t count = r e f 0 while true do l e t! msg = inbox. Receive ( ) count :=! count + 1 p r i n t f n Nachricht %d : %s! count msg }) agent. Post ( Hallo! ) Listing 14: MailboxProcessor Der fun-operator ist an dieser Stelle neu und siganlisiert einen Lambda-Ausdruck, der hier allerdings einfach wie eine anonyme Funktion verwendet wird und die aus der Initialisierung des Postfachs mit MailboxProcessor.Start entstandene inbox an den async-block weiterreicht. Technisch gesehen handelt es sich hierbei um eine Art,,Agent. Der,,Agent kümmert sich in dem Beispiel gewissermaßen autonom um das Verarbeiten der Nachrichten. Mit agent.post( Hallo! ) wird eine Nachricht an den Agenten geschickt und entsprechend des obigen Codes ausgegeben. Der Thread wird auch hier solange pausiert, bis inbox.receive() eine Antwort liefert. Schauen wir uns folgendes Beispiel an, in dem der Agent eine Nachricht geschickt bekommt und darauf Antwortet. type Message = s t r i n g AsyncReplyChannel<s t r i n g > l e t agent = MailboxProcessor<Message >. S t a r t ( fun inbox > async { }) l e t! ( message, replychannel ) = inbox. Receive ( ) ; i f ( message = Stop ) then replychannel. Reply ( Stop ) // Stoppe d i e Ausfuehrung... else replychannel. Reply ( Du hast +message+ gesendet. ) // Fuehre irgendetwas aus... l e t messagehandler input = p r i n t f n Sende : %s input l e t r e p l y = agent. PostAndReply ( fun replychannel > input, replychannel ) i f ( r e p l y <> Stop ) then p r i n t f n Antwort : %s r e p l y else p r i n t f n Gestoppt! Listing 15: MailboxProcessor Um eine Antwort zu erhalten, müssen wir einen AsyncReplyChannel,,mitschicken. Dazu bauen wir uns einen neuen Datentyp Message, der aus einem String und eben jenem AsyncReplyChannel besteht, der in diesem Fall mit string parametrisiert ist und damit auch nur Strings als Antwort geschickt werden dürfen. Der messagehandler kann 6

7 Nachrichten verschicken und erwartet die entsprechende Antwort. Zum Schicken einer Nachricht, auf die eine Antwort erwartet wird, benutzen wir agent.postandreply. Innerhalb dieses Aufrufs bauen wir mittels einer anonymen Funktion die Message, die an den agent geschickt werden soll. Anschließend warten wir (diesmal synchron, also blockierend) auf die Antwort vom agent und verarbeiten sie entsprechend weiter. Der agent pausiert bis die Nachricht eingetroffen ist und verarbeitet sie dann seinerseits weiter. Ein solches,,pattern kann man wunderbar als abstraktes Mittel zur Synchronisation bei der Interprozesskommunikation und insbesondere bei der verteilten Interprozeskommunikation nutzen, um so Probleme wie bspw.,,dining Philosophers zu lösen ohne Gefahr zu laufen,,deadlocks und der gleichen zu erzeugen. 7

8 Quellen Syme, D. (2007): [ ] Syme, D. (2010): [ ] Syme, D. (2010): [ ] Sharp Programming [ ] Sharp %28programming language%29 [ ] [ ] [ ] 8