Tipps zur Codierung von Java-Programmen in Multi-Core-Szenario [geschlossen]

StackOverflow https://stackoverflow.com/questions/601491

Frage

Es scheint eine Menge Lärm um Multicore- und Java zu sein. Während einige Leute sagen, dass die Java-Unterstützung ist nicht href="http://rcr.blogspot.com/2008/03/concurrency-support-in-java7-is-not.html" gut genug , scheint es auf jeden Fall ein Bereich zu sein, zu freuen. Es scheint viele Techniken Leistung konkurrierender Programme zu verbessern.

Irgendwelche Tipps / Hinweise zur Programmierung in einem Multi-Core-Szenario wird geschätzt.

War es hilfreich?

Lösung

Schauen Sie in die neuen Java Concurrency Einrichtungen (in der java.util.concurrent Paket ), die in Java hinzugefügt wurden 5. es Funktionalität bietet, die mehr auf hohe Ebene als normale Threads ist, die es leichter machen werden (und weniger fehleranfällig) gleichzeitige Anwendungen zu schreiben. Die Lektion: Concurrency von Die Java-Tutorials wäre ein guter Ort, um zu starten.

Bisher habe ich nur verwendet, die ExecutorService , die Thread-Pools können produzieren können , zu denen neue Aufgaben können in Einheiten von Runnable s oder Callable s (die Werte nach der Ausführung als Future s), und die tatsächliche Threading-Code wird vom ExecutorService behandelt.

Zum Beispiel einer Berechnung durchgeführt unter Verwendung eines Threadpool von 2 Threads und das Ergebnis bekommen kann so einfach sein wie: 

ExecutorService es = Executors.newFixedThreadPool(2);

Future f1 = es.submit(new Callable<Integer>() {
    public Integer call()
    {
        // Do some processing...
        return someInteger;
    }
});

Future f2 = es.submit(new Callable<Integer>() {
    public Integer call()
    {
        // Do some processing...
        return someInteger;
    }
});

Integer firstInteger = f1.get();
Integer secondInteger = f2.get();

In dem obigen (ungetestet) Code, alles, was ich zu befürchten macht ein paar Callables und submit es zum ExecutorService ing und später, die Futures unter Verwendung des Ergebnisses abzurufen.

Der Haken ist, sobald die get Methode des Future aufgerufen wird, wenn die Verarbeitung nicht abgeschlossen ist, wird das Programm stoppen, bis das Ergebnis der Future abgerufen werden kann. Also, in diesem Beispiel, auch wenn das Ergebnis der f2 vor f1 zur Verfügung steht, wird das Programm warten, bis das Ergebnis f1 verfügbar ist.

In Bezug auf die Lesematerial, auf meiner Liste der Bücher bald zu kaufen ist Java Concurrency in Practice von Brian Goetz, die oft kommt, wenn die Parallelität in Java gebracht.

Die Concurrency Dienstprogramme Seite aus der Java-5-Dokumentation weitere Informationen auch hat.

Andere Tipps

Der beste Tipp hat bekam zu sein: erhalten Sie Ihre Synchronisation korrekt

Dies kann etwas offensichtlich erscheinen, aber ein Verständnis der Java Memory Model ist von entscheidender Bedeutung, vor allem wie volatile und letzte Felder arbeiten, wie synchronisiert fungiert sowohl als Mutex und a Speicherbarriere < em /> und dann die neue java.util.concurrent konstruiert und

Immer ein guter Tipp - wenn die meisten Ihre Klassen unveränderlich sind alles wird so viel einfacher als Unveränderlichkeit die Notwendigkeit, über Sperren von vielen zu wenigen Orten von Interesse zu kümmern entfernt

.

Überprüfen Sie die bevorstehende fork-join rel="nofollow . Die Gabel-Join Framework-Entwickler feinkörnige Parallelität auf Multi-Core-Architekturen zu erreichen ermöglicht.

Auch können Sie JVM überprüfen basierte Sprachen wie Clojure , die Multi-Core-parallele Programmierung zu erleichtern behaupten.

Als Alternative zu Java eigenen Shared-Memory-Ansatz, den Sie in die Parallelität auch in akteursbasierte Parallelität mit Scala oben auf Java, die ein einfacheres Modell für die gleichzeitige Programmierung bietet.

Schauen Sie sich Brian Goetz Vortrag von Concurrent-zu-Parallel von Devoxx 2008. Nicht viele Tipps gibt, aber es gibt Ihnen eine Idee, wo Java Concurrency zu zusteuert.

Sie können versuchen, eine Parallelität Muster-Bibliothek zu verwenden wie Skandium für Java. Wählen Sie einfach die Parallelität Muster, das Sie wollen und die fehlenden Haken füllen.

Einige der Muster sopported in Skandium sind:

  • Master-Slave: Farm<P,R>(nested);
  • Pipeline: `Pipe (Stufe 1, Stufe 2);
  • Für Iteration: For<P,R>(nested, i);
  • Bedingte Iteration: While<P,R>(nested, condition);
  • Bedingte Verzweigung: If<P,R>(condition, trueCase, falseCase);
  • Karte-reduzieren: Map<P,R>(split, nested, merge);
  • Karte-reduce mit unterschiedlichen Codepfade: Fork<P,R>(split, nested, merge);
  • rekursive teile und herrsche: DaC<P,R>(condition, split, nested, merge);

Alle Muster können verschachtelt werden und kombinieren, so können Sie Farm haben innerhalb eines Teile und Herrsche, etc.

Das beste Buch mit praktischen Tipps wurde Java Concurrency in Practice . Es ist ein für alle Java-Programmierer lesen muss, auch diejenigen, die denkt, dass sie tun nicht verantwortlich jede mögliche gleichzeitige Programmierung, weil Java viele versteckte Einfädeln in den verschiedenen Bibliotheken hat (Schaukel in den Sinn kommt, das gleiche mit Servlets).

Mein Tipp: Verstehen Sie das Java-Speichermodell (seit JDK 5 und höher). Die meisten Menschen wissen nicht, dass die Synchronisation, flüchtig und endgültig eine zusätzliche Bedeutung jenseits der normalen Multi-Threading Umfang haben.

Java ist gut für Multi-CPU und Multi-Cores. Wenn Sie es richtig programmieren und Sie einige Gehirne investieren, erhalten Sie ein hoch gleichzeitiges Serversystem 8-Kern mit einer Menge Synchronisation zu nutzen, und so weiter. Wir sind sehr zufrieden damit ... JDK6 ist besser als JDK5 und saugt alles unten auf Multi-CPU-Maschinen.

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top