Parallele und serielle Ströme
Ein paralleler Stream besteht darin, einen Inhalt in mehrere Datenblöcke zu unterteilen und den Stream jedes Datenblocks separat mit verschiedenen Threads zu verarbeiten.
Die parallele Optimierung erfolgt in Java 8, sodass wir die Daten problemlos parallel bedienen können. Die Stream -API kann deklarativ zwischen parallelen und sequentiellen Streams durch parallel () und sequentiell () wechseln.
Verstehen Sie das Fork/Join -Framework
Fork/Join -Framework: Bei Bedarf wird eine große Aufgabe in mehrere kleine Aufgaben aufgeteilt (wenn sie nicht zerlegt werden kann), und dann werden die Ergebnisse des Ausführens jeder kleinen Aufgabe addiert.
Der Unterschied zwischen Fork/Join -Framework und traditionellem Threadpool:
Verwenden Sie den Modus "Work Stealing":
Wenn eine neue Aufgabe ausgeführt wird, kann sie in kleinere Aufgabenausführungen aufgeteilt und der Thread -Warteschlange kleiner Aufgaben hinzufügen, dann eine aus einer Warteschlange von zufälligen Threads stehlen und in eine eigene Warteschlange legen.
Im Vergleich zur Implementierung des allgemeinen Threadpools spiegeln sich die Vorteile des Fork/Join -Frameworks in der Art und Weise wider, die die darin enthaltenen Aufgaben umgehen. Wenn im allgemeinen Threadpool ein Thread eine Aufgabe ausführt, die aus irgendeinem Grund nicht ausführen kann, befindet sich der Thread in einem Wartezustand. Wenn jedoch in der Implementierung von Fork/Join Framework ein Teilproblem nicht weiter ausführen kann, da es auf den Abschluss eines anderen Teilproblems wartet. Dann sucht der Thread, der das Unterproblem übernimmt, aktiv nach anderen Unterproblemen, die für die Ausführung noch nicht ausgeführt wurden. Diese Methode verkürzt die Wartezeit des Threads und verbessert die Leistung.
import Java.time xx) {} private static void test1 () {Instant start = Instant.now (); Forkjoinpool pool = new forkjoinpool (); Forkjointask <long> task = new Forkjoincalculate (0L, 1000000000L); lange Summe = Pool.invoke (Aufgabe); System.out.println (sum); Instant End = Instant.now (); System.out.println ("Verbrauchszeit"+Dauer. Lange sum = longstream.rangecloses (0l, 10000L) .Parallel () .Reduce (0, lang :: sum); System.out.println (sum); Instant End = Instant.now (); System.out.println ("Verbrauchszeit" + Dauer. privates langes Ende; private statische endgültige lange Schwelle = 2500000000L; // Kritischer Wert Public Forkjoincalculate (langes Start, langes Ende) {this.start = start; this.end = Ende; } @Override geschützt long compute () {long länge = end - start; if (Länge <= Schwelle) {long sum = 0; für (long i = start; i <= end; i ++) {sum+= i; } Return Sum; } else {long Middle = (Start+Ende)/2; Forkjoincalculate links = New Forkjoincalculate (Start, Mitte); links.Fork (); Forkjoincalculate Right = New Forkjoincalculate (Middle+1, Ende); rechts.Fork (); return links.join () + rechts.Join (); }}}Optionale Klasse
Optionale <t> Klasse (java.util.Optional) ist eine Containerklasse, die darstellt, ob ein Wert existiert oder nicht existiert.
Es stellt sich heraus, dass Null bedeutet, dass ein Wert nicht existiert und jetzt optional dieses Konzept besser ausdrücken kann. Und es kann Null -Zeigerausnahmen vermeiden.
Häufige Methoden:
Optional.of (t t): Erstellen Sie eine optionale Instanz
Optional.Empty (): Erstellen Sie eine leere optionale Instanz
Optional.ofnullable (t t): Wenn T nicht null ist, erstellen Sie eine optionale Instanz, andernfalls erstellen Sie eine leere Instanz.
isPresent (): Bestimmt, ob der Wert enthalten ist
Orelse (t t): Wenn das Anrufobjekt einen Wert enthält, geben Sie den Wert zurück, ansonsten t zurück t
Orelseget (Lieferant): Wenn das Anrufobjekt einen Wert enthält, geben Sie den durch s erhaltenen Wert zurück.
Karte (Funktion f): Wenn es einen Wert gibt, um es zu verarbeiten, und die verarbeitete optionale zurückgibt, gibt es ansonsten optional zurück.
flatMap (Funktion mapPer): Ähnlich wie bei der Karte muss der Rückgabewert optional sein
public class optionalTest1 {public static void main (String [] args) {String s = new String ("ha"); // optional <string> op = optional.of (null); // // string s1 = op.get (); // system.out.println (S1); // optional <string> op1 = optional.empty (); // String s1 = op1.get (); // system.out.println (S1); Optional <string> op1 = optional.ofnullable (null); // system.out.println (op1.ipresent ()); // system.out.println (op1.orelse (neuer String ("Google")); //System.out.println (op1.orelseget () -> new String ("ali"))); Optional <string> op2 = op1.map ((x) -> x.tolowerCase ()); String s2 = op2.get (); System.out.println (S2); }} @Test public void test5 () {Man Man = new Man (); String name = getGodnessName (Mann); System.out.println (Name); } // Anforderungen: Holen Sie sich den Namen der Göttin im Herzen eines Menschen öffentliche String GetgodnessName (Mann) {if (Mann! = Null) {Godness g = man.getGod (); if (g! = null) {return g.getName (); }} return "Lehrer CANG"; } // Optionale Entitätsklasse @test public void test6 () {optional <godness> gottness = optional.ofnullable (New Godness ("Lin Chiling"); Optional <Newman> op = optional.ofnullable (Newman (Godness)); String name = getGodnessName2 (op); System.out.println (Name); } public String getgodnessName2 (optional <Newman> Man) {return Man.orelse (Newman ()) .getGodness () .orelse (New Godness ("Lehrer CANG") .getName (); } // HINWEIS: Optional kann nicht serialisiert werden. privater Göttlichkeit Gott; public optional <godness> getgod () {return optional.of (Gott); } public newman () {} public Newman (optional <göttlichkeit> göttlich) {this.godness = gottness; } public optional <godness> getgodness () {göttlich zurückgeben; } public void setgodness (optionale <göttlichkeit> göttlich) {this.godness = gottness; } @Override public String toString () {return "newman [gottess =" + gottess + "]"; }}Das obige ist die Erfahrung mit der Verwendung der Forkjoin- und optionalen Frameworks in Java 8, die wir für Sie zusammengestellt haben. Wenn Sie immer noch nichts verstehen, was Sie beim Lernen nicht verstehen, können Sie es im Nachrichtenbereich unten besprechen.