Moderne Programmiersprache mit intuitiven Abstraktionen für die gleichzeitige Programmierung

Ich interessiere mich für das Erlernen der gleichzeitigen Programmierung, wobei ich mich auf die Anwendungs- / Benutzerebene konzentriere (nicht auf die Systemprogrammierung). Ich bin auf der Suche nach einer modernen Programmiersprache auf hohem Niveau, die intuitive Abstraktionen zum Schreiben von gleichzeitigen Anwendungen bietet. Ich möchte mich auf Sprachen konzentrieren, die die Produktivität steigern und die Komplexität der gleichzeitigen Programmierung verbergen.

Um einige Beispiele zu nennen: Ich halte es nicht für eine gute Option, Multithread-Code in C, C ++ oder Java zu schreiben, da meiner Meinung nach meine Produktivität abnimmt und das Programmiermodell nicht intuitiv ist. Andererseits sind Sprachen, die die Produktivität steigern und intuitivere Abstraktionen bieten, wie Python und das Multiprozessormodul, Erlang, Clojure, Scala usw., gute Optionen.

Was würden Sie aufgrund Ihrer Erfahrungen empfehlen und warum?

EDIT: Vielen Dank für Ihre interessanten Antworten. Es ist schwer, eine Schlussfolgerung zu ziehen, ohne es tatsächlich zu versuchen, da es viele gute Kandidaten gibt: Erlang, Clojure, Scala, Groovy und vielleicht Haskell. Ich habe die Antwort mit den überzeugendsten Argumenten gewählt, aber ich werde alle guten Kandidaten ausprobieren, bevor ich mich für einen entschieden habe :)

Sie sollten sich mit ziemlicher Sicherheit Clojure ansehen - meiner Meinung nach ist es die beste moderne Sprache für Multi-Core-Programmierung und äußerst produktiv.

Hauptmerkmale:

• Es ist eine funktionale Sprache , die sowohl für die Nebenläufigkeit als auch für Ihre Fähigkeit, sich mithilfe von Abstraktionen auf höherer Ebene zu entwickeln, von Vorteil ist. Es bietet unveränderliche persistente Datenstrukturen und verzögerte Sequenzen, die jedem vertraut sind, der Erfahrung mit funktionalen Sprachen wie Haskell hat.
• Es verfügt über ein neuartiges Software-Transaktionsspeichersystem für den gleichzeitigen sperrfreien Zugriff auf den veränderlichen Status. Das gleichzeitige Sichern von Code ist häufig so einfach wie das Umschließen in einen (dosync ....) - Block.
• Es ist ein Lisp - was es für die makrobasierte Metaprogrammierung und Codegenerierung extrem leistungsfähig macht. Dies kann erhebliche Produktivitätsvorteile bringen (Aufsatz von Paul Graham - "Beating The Averages")
• Es ist eine JVM-Sprache. Sie erhalten also nicht nur Zugriff auf die zahlreichen Bibliotheken und Tools des Java-Ökosystems, sondern profitieren auch von dem enormen technischen Aufwand, der erforderlich ist, um die JVM zu einer effektiven Plattform für gleichzeitige serverseitige Anwendungen zu machen. Für die Praxis bedeutet dies einen enormen Vorteil gegenüber Sprachen, auf die man nicht aufbauen kann.
• Es ist dynamisch - was zu sehr präzisem Code und hoher Produktivität führt. Beachten Sie jedoch, dass Sie bei Bedarf optionale statische Typhinweise für die Leistung verwenden können.
• Die Sprache basiert auf Abstraktionen, die etwas schwer zu erklären sind, aber der Nettoeffekt ist, dass Sie eine Reihe relativ orthogonaler Merkmale erhalten, die Sie kombinieren können, um Ihre Probleme zu lösen. Ein Beispiel wäre die Sequenzabstraktion, mit der Sie Code schreiben können, der sich mit jedem "sequentiellen" Objekttyp befasst (der alles aus Listen, Zeichenfolgen, Java-Arrays, unendlichen verzögerten Sequenzen, aus einer Datei gelesenen Zeilen usw. umfasst).
• Es gibt eine großartige Community - hilfreich, aufschlussreich, aber vor allem sehr pragmatisch - der Fokus in Clojure liegt im Allgemeinen darauf, "Dinge zu erledigen".

Einige Mini-Codebeispiele mit einer Parallelitätsneigung:

;; define and launch a future to execute do-something in another thread
(def a (future (do-something)))

;; wait for the future to finish and print its return value
(println @a)

;; call two functions protected in a single STM transaction
(dosync
  (function-one)
  (function-two))

Insbesondere lohnt es sich, eines oder mehrere der folgenden Videos anzusehen:

• http://www.infoq.com/presentations/Value-Identity-State-Rich-Hickey
• http://www.infoq.com/presentations/Are-We-There-Yet-Rich-Hickey
• http://www.infoq.com/presentations/Clojure-The-Art-of-Abstraction

Sie könnten D. versuchen. Es bietet drei Modelle. Ich empfehle entweder die erste oder die zweite.

1. std.concurrency . Wenn Sie dieses Modul für alle Ihre Anforderungen an die Parallelität verwenden, erzwingt eine Kombination aus Sprache und Standardbibliothek die Isolation zwischen Threads. Threads kommunizieren hauptsächlich über die Nachrichtenübermittlung, wobei der gemeinsam genutzte Speicher nur eingeschränkt unterstützt wird, sodass die Sicherheit an erster Stelle steht und Datenrennen auf niedriger Ebene nicht zugelassen werden. Leider muss die Dokumentation von std.concurrency verbessert werden, aber das Modell ist in einem kostenlosen Kapitel von Andrei Alexandrescus Buch "The D Programming Language" dokumentiert .

2. Standardparallelismus . Dieses Modul wurde speziell für Multicore-Parallelität und nicht für die allgemeine Parallelität entwickelt. ( Parallelität und Parallelität sind nicht dasselbe, obwohl Parallelität erforderlich ist, um Parallelität zu implementieren. ) Da der springende Punkt der Parallelität die Leistung ist, garantiert std.parallelism keine Isolation, da sie das Schreiben von effizientem Parallelcode erschweren würden. Es werden jedoch viele fehleranfällige Details auf niedriger Ebene entfernt, so dass es sehr schwierig ist, Fehler zu beheben, wenn Sie Workloads parallelisieren, die Sie manuell überprüft haben und die voneinander unabhängig sind.

3. core.thread ist ein Low-Level-Wrapper für betriebssystemspezifische Threading-APIs. Sowohl std.concurrency als auch std.parallelism verwenden es unter der Haube, aber ich würde es nur empfehlen, wenn Sie Ihre eigene Parallelbibliothek schreiben oder eine lächerliche Ecke finden, die weder in std.parallelism noch in std gut gemacht werden kann .währung. Niemand sollte etwas so Niedriges für die tägliche Arbeit verwenden.

Erlang ist definitiv eine großartige Option, aber etwas Praktischeres könnte Go sein , Googles neue Sprache.

Es ist nicht so weit von anderen gebräuchlichen Sprachen entfernt, daher ist es normalerweise leicht zu bekommen, wenn Sie bereits andere "einfache" Sprachen kennen. Viele Leute vergleichen es mit Python oder sogar Lua, wenn es darum geht, wie komfortabel es ist, es zu programmieren.

Schauen Sie sich Microsofts Parallel Programming for .net an. Es ist sehr intuitiv.

Viele PCs und Workstations verfügen über zwei oder vier Kerne (dh CPUs), mit denen mehrere Threads gleichzeitig ausgeführt werden können. Computer werden in naher Zukunft voraussichtlich deutlich mehr Kerne haben. Um die Hardware von heute und morgen zu nutzen, können Sie Ihren Code parallelisieren, um die Arbeit auf mehrere Prozessoren zu verteilen. In der Vergangenheit erforderte die Parallelisierung eine Manipulation von Threads und Sperren auf niedriger Ebene. Visual Studio 2010 und .NET Framework 4 verbessern die Unterstützung für die parallele Programmierung, indem sie eine neue Laufzeit, neue Klassenbibliothekstypen und neue Diagnosetools bereitstellen. Diese Funktionen vereinfachen die parallele Entwicklung, sodass Sie effizienten, feinkörnigen und skalierbaren parallelen Code in einer natürlichen Sprache schreiben können, ohne direkt mit Threads oder dem Thread-Pool arbeiten zu müssen.

Sowohl Erlang als auch Scala haben eine auf Schauspielern basierende Parallelität , die ich als sehr intuitiv und leicht erlernbar empfand.

Das Actor-Modell in der Informatik ist ein mathematisches Modell der simultanen Berechnung, das "Akteure" als universelle Grundelemente der simultanen digitalen Berechnung behandelt: Als Antwort auf eine empfangene Nachricht kann ein Akteur lokale Entscheidungen treffen, mehr Akteure erstellen, mehr Nachrichten senden und bestimmen, wie auf die nächste empfangene Nachricht zu reagieren ist ... Sie wurde sowohl als Rahmen für ein theoretisches Verständnis der Berechnung als auch als theoretische Grundlage für mehrere praktische Implementierungen von gleichzeitigen Systemen verwendet.

Ich lerne gerade etwas über Haskell und das Lesen dieses Artikels hat mich überzeugt, dass Haskell eine gute Option für die gleichzeitige Programmierung ist. Da es rein funktional ist (das Typsystem weiß, ob eine Funktion Eingaben, Ausgaben oder das Lesen / Ändern des globalen Zustands ausführt), kann es Dinge wie Software-Transaktionsspeicher (im obigen Artikel sehr gut zusammengefasst) ausführen, die sich ähnlich wie Transaktionen verhalten in datenbanken bekommt man ein paar nette sachen wie atomicity mit nur ein wenig extra zucker. AFAIK, Haskell-Fäden sind auch sehr leicht. Darüber hinaus können durch die Tatsache, dass Haskell rein funktional ist, auch einfache Aufgaben mit nur einem Schlüsselwort (par) parallel ausgeführt werden. Quelle

Googles GO-Sprache bietet einige interessante Tools für den gleichzeitigen Zugriff - das wäre eine weitere unterhaltsame Sache, die Sie ausprobieren sollten. Siehe: http://golang.org/doc/effective_go.html#concurrency und lesen Sie einige Beispiele.

Die gleichzeitige Programmierung ist ein großes Thema, und hier ist nur Platz für einige Go-spezifische Highlights.

Die gleichzeitige Programmierung in vielen Umgebungen wird durch die Feinheiten erschwert, die für den korrekten Zugriff auf gemeinsam genutzte Variablen erforderlich sind. Go befürwortet einen anderen Ansatz, bei dem gemeinsame Werte auf Kanälen weitergegeben werden und in der Tat niemals von separaten Ausführungsthreads aktiv geteilt werden. Es hat immer nur eine Goroutine Zugriff auf den Wert. Datenrennen können nicht beabsichtigt auftreten. Um dieses Denken zu fördern, haben wir es auf einen Slogan reduziert:

Kommunizieren Sie nicht, indem Sie Speicher freigeben. Teilen Sie stattdessen den Speicher, indem Sie kommunizieren.

Dieser Ansatz kann zu weit gehen. Referenzzählungen können am besten durchgeführt werden, indem beispielsweise ein Mutex um eine Ganzzahlvariable gelegt wird. Auf hoher Ebene erleichtert die Verwendung von Kanälen zur Zugriffssteuerung das Schreiben klarer und korrekter Programme.

Eine Möglichkeit, über dieses Modell nachzudenken, besteht darin, ein typisches Single-Thread-Programm zu betrachten, das auf einer CPU ausgeführt wird. Es sind keine Synchronisationsprimitive erforderlich. Führen Sie nun eine weitere Instanz aus. es braucht auch keine Synchronisation. Lassen Sie nun diese beiden kommunizieren; Wenn es sich bei der Kommunikation um den Synchronizer handelt, ist nach wie vor keine weitere Synchronisierung erforderlich. Unix-Pipelines passen beispielsweise perfekt zu diesem Modell. Der Ansatz von Go zur Parallelität geht zwar auf Hoares CSP (Communicating Sequential Processes) zurück, kann aber auch als typsichere Verallgemeinerung von Unix-Pipes angesehen werden ...

In der nächsten Version macht es C # noch einfacher, als das Diagramm zeigt. Es gibt zwei neue Schlüsselwörter Async und Await.

Async wird als Funktionsmodifikator verwendet und sagt: "Diese Operation führt ihre Arbeit an einem anderen Thread aus.

Await wird in einer Async-Funktion verwendet, und hier geschieht die Magie. Grundsätzlich weist Await den Compiler an, die Operation nach dem Schlüsselwort in einem separaten Thread auszuführen und auf die Ergebnisse zu warten. Jeder Code nach dem Warteaufruf wird nach der Operation ausgeführt.

AUCH die Operation wird mit dem aufrufenden Thread synchronisiert (wenn Sie also eine asynchrone Operation als Reaktion auf einen Tastenklick ausführen, müssen Sie nicht manuell zurück in den UI-Thread posten). Mit zwei kleinen Stichwörtern erhalten Sie eine Menge Parallelität. Lesen Sie hier mehr

Ich würde weiterhin C ++ empfehlen. Es ist mehr als fähig, die notwendigen Abstraktionen zu erzeugen, um anständigen gleichzeitigen Code zu schreiben. Die überwältigende Wahrscheinlichkeit ist, dass Sie einfach eine schlechte Bibliothek für die Ausführung der Aufgabe haben, da gute Bibliotheken für die Ausführung der Aufgabe relativ neu sind und das Wissen für die Verwendung von C ++ nicht gerade allgemein ist. Intels TBB gibt es erst seit ein paar Jahren, und Microsofts PPL wurde erst seit letztem Jahr ausgeliefert.

Wenn Sie so etwas wie TBB oder PPL verwenden, ist das Schreiben von gleichzeitigem Code nicht gerade trivial , sofern die gleichzeitige Verwendung nie trivial ist, sondern alles andere als mühsam. Wenn Sie pthreads oder Win32-Threads direkt verwenden, ist es kein Wunder, dass Sie es nicht mögen - Sie schreiben praktisch in Assembler mit solchen Funktionen. Aber mit der PPL sprechen Sie über standardmäßige Funktionsalgorithmen, die für Sie parallelisiert sind, generische Datenstrukturen für den gleichzeitigen Zugriff und solche guten Dinge.

Hier wird ein Plug für Ada benötigt, da es alle Abstraktionen der obersten Ebene für Parallelität und Parallelität enthält. sonst bekannt als tasking . Auch als OP nach intuitiven (subjektiven) Kriterien fragte, denke ich, dass ein anderer Ansatz für die Java-zentrierte Welt geschätzt werden könnte.

Ich würde Groovy / Java / GPars vorschlagen, wenn Sie JVM-basiert sein können, da es Akteure, Datenfluss, Kommunikation sequentieller Prozesse (CSP), Datenparallelität, Software-Transaktionsspeicher (STM), Agenten usw. ermöglicht Es gibt viele Modelle für Parallelität und Parallelität auf hoher Ebene, die jeweils unterschiedliche "Sweet Spots" aufweisen. Sie möchten kein Modell verwenden, das nicht mit der Lösung eines Problems übereinstimmt, das Sie erstellen möchten. Sprachen und Frameworks mit nur einem Modell zwingen Sie zum Algorithmus-Hacking.

Natürlich könnte ich als voreingenommen angesehen werden, da ich zu Groovy und GPars beitrage. Andererseits arbeite ich mit CSP und Python, vgl. Python-CSP.

Ein weiterer Punkt ist, dass es bei der ursprünglichen Frage nicht um das Schreiben eines Produktionssystems, sondern um das Lernen geht. Daher ist die Groovy / Java / GPars-Kombination eine gute Möglichkeit zum Lernen, auch wenn die spätere Produktionsarbeit in C ++ mit etwas wie Just :: Thread Pro oder TBB ausgeführt wird, anstatt auf JVM zu basieren.

(Einige absolut vernünftige URL-Links mussten entfernt werden, weil die Host-Site in Panik geriet.)

Was ist mit Clojure? Sie können Swing zum Beispiel verwenden, aber gleichzeitig mit Clojure programmieren? Clojure hat eine ziemlich gute Java-Integration.

Haben Sie auch Java 7 Fork / Join-Framework in Betracht gezogen ?

Sie können sich auch Groovy und die GPars- Bibliothek ansehen . GPars BTW ähnelt in gewisser Weise der in einer anderen Antwort erwähnten .NET Parallel Extension, wird jedoch durch die flexible Syntax von Groovys unter bestimmten Umständen besser gelesen.

Scala wurde mehrmals in den Fragen und Antworten erwähnt, aber ich habe keinen Hinweis auf Akka gesehen , eine Schauspielerimplementierung, die sowohl mit Scala als auch mit Java verwendet werden kann.

Ich denke, es hängt davon ab, was Sie bauen. Desktop-Apps oder Server? Ich habe gehört, dass node.j (ohne persönliche Erfahrung) hervorragend für die gleichzeitige Programmierung von Servern geeignet ist (sowohl in Bezug auf das Schreiben von Code als auch in Bezug auf die Leistung). Wenn ich eine neue Server-App schreiben wollte, würde ich das wahrscheinlich ausprobieren. Nicht sicher über Desktop-Anwendungen ... Ich habe eine ganze Menge Dinge in C # geschrieben und es gibt einige Tools, die die Komplexität gut verbergen, obwohl Sie in anderen Fällen direkt damit umgehen müssen.

Ich werde dafür vielleicht über den Kopf geschlagen, aber haben Sie Kapitel 7 von TAOUP gelesen ? Der Abschnitt, an den ich gerade denke, ist Themen gegen Prozesse. Ich habe festgestellt, dass das Konzept der gleichzeitigen Verarbeitung die meisten Leute an Threads erinnert, aber ich habe noch nie einen Fall gesehen, in dem ein Thread einfacher und schneller zu verwenden ist als das Erzeugen eines untergeordneten Prozesses.

Sie überlassen den Schlauen, die Ihr Betriebssystem erstellt haben, alle Details der Parallelverarbeitung. Es gibt bereits viele Kommunikationsmethoden, und Sie müssen sich keine Gedanken über das Sperren freigegebener Ressourcen machen. Threads sind grundsätzlich ein Effizienz-Hack, der der Regel der Optimierung unterliegt. Optimieren Sie nicht, wenn Sie nicht auf Notwendigkeit getestet haben.

Suchen Sie eine gute Unterprozessbibliothek, z. B. Envoy for Python . Oder Sie schreiben einfach mehrere separate Programme in C und schreiben ein anderes "Master" -Programm, um mithilfe von Fork und Pipe die Unterprozesse zu erzeugen und mit ihnen zu kommunizieren.