Streams parallèles et en série
Un flux parallèle consiste à diviser un contenu en plusieurs blocs de données et à traiter le flux de chaque bloc de données séparément avec différents threads.
L'optimisation parallèle est effectuée dans Java 8, nous pouvons donc facilement utiliser les données en parallèle. L'API de flux peut basculer de déclaration entre les flux parallèles et séquentiels via parallel () et séquentiel ().
Comprendre le cadre Fork / Join
Frame de fourche / jointure: Si nécessaire, une grande tâche est divisée en plusieurs petites tâches (lorsqu'elle ne peut pas être démontée), puis les résultats de l'exécution de chaque petite tâche sont additionnés.
La différence entre le framework Fork / Join et le pool de threads traditionnels:
Utilisez le mode "travail de travail":
Lorsqu'une nouvelle tâche est exécutée, elle peut la diviser en exécutions de tâches plus petites et ajouter de petites tâches à la file d'attente, puis en voler une dans une file d'attente de threads aléatoires et le mettre dans sa propre file d'attente.
Par rapport à l'implémentation générale du pool de threads, les avantages du cadre Fork / Join sont reflétés dans la manière de gérer les tâches qui y sont contenues. Dans le pool de threads généraux, si un thread exécute une tâche qui ne peut pas continuer à s'exécuter pour une raison quelconque, le thread sera dans un état d'attente. Cependant, dans l'implémentation du framework Fork / Join, si un sous-problème ne peut pas continuer à s'exécuter car il attend l'achèvement d'un autre sous-problème. Ensuite, le fil qui gère le sous-problème recherchera activement d'autres sous-problèmes qui n'ont pas encore été exécutés pour exécution. Cette méthode réduit le temps d'attente du fil et améliore les performances.
Importer Java.Time.Duration; Importer java.time.instant; import java.util.concurrent.forkjoinpool; import java.util.concurrent.forkjointask; import java.util.concurrent.recursivetask; import java.util.stream.longstream; public class testForkjoin {public static void seri xx) {} private static void test1 () {instant start = instant.now (); Forkjoinpool pool = new ForkJoinpool (); FORKJOINTASK <long> task = new FORKJOncalculate (0L, 1000000000L); Sum long = pool.invoke (tâche); System.out.println (SUM); Instant fin = instant.now (); System.out.println ("consommateur de consommation" + durée.between (start, end) .tomillis () + "ms"); // temps de consommation 3409ms} private static void test2 () {instant start = instant.now (); Sum long = longStream.Rangeclosed (0l, 10000L) .Parallel () .reduce (0, long :: sum); System.out.println (SUM); Instant fin = instant.now (); System.out.println ("Temps de consommation" + durée.between (start, fin) .tomillis () + "ms"); // temps de consommation 2418 ms}} class Forkjoincalculate étend récursiveTask <long> {numéro privé privé static statial long long; Longue fin privée; Seuil long final statique privé = 2500000000L; // Valeur critique Forkjoincalculate (Long Start, Long End) {this.start = start; this.end = end; } @Override Protected Long Compute () {long Longueur = end - start; if (longueur <= threshold) {long sum = 0; pour (long i = start; i <= end; i ++) {sum + = i; } RETOUR SUM; } else {long middle = (start + end) / 2; FORKJOncalculate Left = new Forkjoincalculate (début, milieu); Left.Fork (); Forkjoincalculate à droite = new Forkjoincalculate (milieu + 1, end); droite.Fork (); return gauche.join () + droit.join (); }}}Classe facultative
La classe <T> Facultatif (java.util.optional) est une classe de conteneurs qui représente si une valeur existe ou n'existe pas.
Il s'avère que NULL signifie qu'une valeur n'existe pas, et désormais facultatif peut mieux exprimer ce concept. Et cela peut éviter les exceptions de pointeur nul.
Méthodes courantes:
Facultatif.of (t t): Créez une instance facultative
Facultatif.Empty (): Créez une instance facultative vide
Facultatif.ofNullable (t t): Si t n'est pas nul, créez une instance facultative, sinon créez une instance vide.
isPresent (): détermine si la valeur est incluse
orelse (t t): Si l'objet d'appel contient une valeur, renvoyez la valeur, sinon renvoyez t
Orelseget (fournisseur): Si l'objet d'appel contient une valeur, renvoyez la valeur obtenue par S.
map (fonction f): S'il y a une valeur pour le traiter et renvoie le traitement facultatif, sinon, il renvoie en option.empty ()
FlatMap (Fonction Mapper): Similaire à MAP, la valeur de retour doit être facultative
classe publique FORTEALTEST1 {public static void main (String [] args) {String s = new String ("ha"); // facultatif <string> op = optional.of (null); // // string s1 = op.get (); // system.out.println (s1); // Facultatif <string> op1 = optional.empty (); // string s1 = op1.get (); // system.out.println (s1); Facultatif <string> op1 = optional.ofNullable (null); // system.out.println (op1.ispresent ()); // system.out.println (op1.orelse (new String ("google"))); //System.out.println (op1.orelSeget (() -> new String ("Ali"))); Facultatif <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 (man); System.out.println (nom); } // Exigences: Obtenez le nom de la déesse dans le cœur d'un homme String public getGodnessName (man man) {if (man! = Null) {godness g = man.getgod (); if (g! = null) {return g.getName (); }} return "professeur CANG"; } // Utilisez une classe d'entité facultative @Test public void test6 () {facultatif <Godness> godness = facultatif.ofNullable (new godness ("lin chiling")); Facultatif <Newman> op = Facultatif.OfNullable (Newman (Godness)); String name = getGodnessName2 (op); System.out.println (nom); } public String getGodnessName2 (facultatif <Newman> man) {return man.Orelse (new Newman ()) .getGodness () .Orelse (new Godness ("Teacher CANG")) .GetName (); } // Remarque: Facultatif ne peut pas être la classe publique sérialisée newman {privé facultatif <podness> godness = optional.empty (); Dieu privé Dieu; public Facultatif <Godness> getgod () {return facultatif.of (dieu); } public Newman () {} public Newman (facultatif <Godness> Godness) {this.godness = godness; } public Facultatif <Godness> getGodness () {return godness; } public vide setGodness (facultatif <Godness> Godness) {this.godness = godness; } @Override public String toString () {return "newman [godness =" + godness + "]"; }}Ce qui précède est toute l'expérience de l'utilisation de la forkjoin et des cadres facultatifs dans Java 8 que nous avons compilés pour vous. Si vous ne comprenez toujours rien que vous ne comprenez que lorsque vous apprenez, vous pouvez en discuter dans la zone de message ci-dessous.