Dois-je toujours utiliser un courant parallèle lorsque cela est possible?

Avec Java 8 lambdas et il est facile de parcourir les collections comme des ruisseaux, et tout aussi facile à utiliser un courant parallèle. Deux exemples de les docs, le second en utilisant parallelStream:

myShapesCollection.stream()
    .filter(e -> e.getColor() == Color.RED)
    .forEach(e -> System.out.println(e.getName()));

myShapesCollection.parallelStream() //<-- This one uses parallel
    .filter(e -> e.getColor() == Color.RED)
    .forEach(e -> System.out.println(e.getName()));

Tant que je ne se soucient pas de l'ordre, ne serait-il toujours être intéressant d'utiliser le parallèle? On pourrait penser qu'il est plus rapide la division du travail sur plus de cœurs.

Existe-il d'autres considérations? Quand doit-courant parallèle être utilisé et à quel moment les non-parallèle-elle être utilisée?

^{(Cette question est posée pour déclencher une discussion au sujet de comment et quand utiliser les flux parallèles, pas parce que je pense toujours à l'aide de eux est une bonne idée).}

InformationsquelleAutor Matsemann | 2013-12-04

595

Un courant parallèle a beaucoup plus de frais généraux par rapport à un séquentiel. Coordonner les fils prend beaucoup de temps. Je voudrais utiliser séquentielle flux par défaut et ne prennent en considération parallèles si
- J'ai une énorme quantité d'éléments à traiter (ou le traitement de chaque élément prend du temps et est parallélisable)
- J'ai un problème de performance, en premier lieu,
- Je n'ai pas déjà exécuté le processus dans un environnement multithread (par exemple: dans un conteneur web, si j'ai déjà beaucoup de demandes à traiter en parallèle, l'ajout d'une couche supplémentaire de parallélisme à l'intérieur de chaque demande pourrait avoir plus négatifs que d'effets positifs)
Dans votre exemple, le rendement sera de toute façon être entraînée par l'accès synchronisé à System.out.println(), et de faire de ce processus parallèle n'aura aucun effet, ou même négative.

En outre, n'oubliez pas que les ruisseaux parallèles ne pas magique pour résoudre tous les problèmes de synchronisation. Si une ressource partagée est utilisée par les prédicats et fonctions utilisées dans le processus, vous devrez vous assurez que tout est thread-safe. En particulier, les effets secondaires sont des choses que vous avez vraiment besoin de vous inquiéter si vous allez en parallèle.

En tout cas, de mesurer, de ne pas le deviner! Seulement une mesure de vous dire si le parallélisme en vaut la peine ou pas.
- La bonne réponse. Je voudrais ajouter que si vous avez une quantité massive d'éléments à traiter, qui augmente seulement le fil de problèmes de coordination, c'est seulement quand le traitement de chacun de ces éléments prend du temps et est parallélisable que la parallélisation peut être utile.
- Je suis en désaccord. Le Fork/Join système suffit de séparer les N éléments, par exemple, 4 pièces, et les processus de ces 4 parties de façon séquentielle. 4 résultats seront ensuite réduits. Si massive est vraiment énorme, même pour rapide de l'unité de traitement, la parallélisation peut être efficace. Mais comme toujours, vous devez mesurer.
- j'ai une collection d'objets qui implémentent Runnable que j'appelle start() de les utiliser comme Threads, est-il ok pour changer cela à l'aide de java 8 flux de données dans un .forEach() parallélisée ? Puis je serais en mesure de dépouiller le fil code de la classe. Mais existe-il des inconvénients?
- Si 4 pièces d'effectuer de manière séquentielle, alors il n'y a pas de différence de processus parallèles ou séquentielle savoir? Pls préciser
- il signifie évidemment que les éléments de chacune des 4 parties seront traitées de manière séquentielle. Toutefois, les parties elles-mêmes peuvent être traitées simultanément. En d'autres termes, si vous disposez de plusieurs cœurs de processeurs disponibles, chaque partie peut fonctionner sur son propre cœur indépendamment des autres parties, tandis que le traitement de ses propres éléments de manière séquentielle. (NOTE: je ne sais pas, si c'est de cette façon parallèle Java flux de travail, je suis juste essayer de clarifier ce que JBNizet voulait dire.)
- Combien est "massive"? Comme toujours, la mesure est la clé, mais que doit-on le classer comme "massif"?
- Je pense que le dernier point doit avoir été mis en gras In any case, measure, don't guess! Only a measurement will tell you if the parallelism is worth it or not.. En parallèle de lire sur la liste de pousser java pour frayer les threads de lire la liste. Lorsque vous travaillez avec des processus qui ne sont pas de frai fils parallélisme devient utile. Par exemple l'exécution d'une tâche au printemps managed bean où le printemps en garde un thread pour le traitement de la tâche à l'intérieur de la fève. Tous les scénarios de traitement est différent et, sans peaufinage et la mesure ce qui améliore le traitement ou non, elle sera incomplète analogie.
InformationsquelleAutor JB Nizet
204

Le Flux de l'API a été conçu pour rendre plus facile l'écriture des calculs dans un chemin qui a été prélevée à l'écart de la façon dont ils seraient exécutés, faire de la commutation entre les parallèles et séquentielles facile.

Cependant, juste parce qu'elle est facile, ne signifie pas que c'est toujours une bonne idée, et en fait, c'est un mauvais idée de tout laisser tomber, .parallel() tous sur la place tout simplement parce que vous le pouvez.

Tout d'abord, notez que le parallélisme n'offre pas d'avantages autres que la possibilité d'une exécution plus rapide lorsque plus de cœurs sont disponibles. Une exécution parallèle impliquera toujours plus de travail que d'un séquentiel, parce que, en plus de résoudre le problème, il faut aussi effectuer la répartition et la coordination des sous-tâches. L'espoir est que vous serez en mesure d'obtenir pour la réponse rapide en décomposant le travail sur plusieurs processeurs; si cela se produit dépend de beaucoup de choses, y compris la taille de votre ensemble de données, combien de calcul que vous faites sur chaque élément, la nature du calcul (en particulier, le traitement d'un élément d'interagir avec le traitement des autres?), le nombre de processeurs disponibles, et le nombre d'autres tâches concurrentes pour ces processeurs.

De plus, notez que le parallélisme également expose souvent des non-déterminisme dans le calcul qui est souvent caché par séquentielle implémentations; parfois, cela n'a pas d'importance, ou peut être atténué en limitant les opérations (c'est à dire, la réduction des opérateurs doit être apatride et associatif.)

Dans la réalité, parfois parallélisme permettra d'accélérer votre calcul, parfois, il ne sera pas, et parfois il va même jusqu'à le ralentir. Il est préférable de développer d'abord à l'aide de l'exécution séquentielle et ensuite appliquer le parallélisme où (Un) vous savez qu'il ya effectivement des avantages à l'augmentation des performances et (B) qu'il va effectivement offrir des performances accrues. (A) est un problème d'entreprise, pas d'ordre technique. Si vous êtes un spécialiste, vous aurez généralement être en mesure de regarder le code et de déterminer (B), mais le smart chemin est à mesurer. (Et ne même pas la peine jusqu'à ce que vous êtes convaincu de (A); si le code est assez rapide, mieux appliquer votre cerveau cycles d'ailleurs.)

Le plus simple modèle de performance pour le parallélisme est le "NQ" modèle, où N est le nombre d'éléments, et Q est le calcul par élément. En général, vous avez besoin du produit NQ dépasser un certain seuil avant que vous commencez à obtenir un avantage de performance. Pour un faible Q problème comme "ajouter des nombres de 1 à N", vous aurez généralement voir un équilibre entre N=1000 et N=10000. Avec plus de Q problèmes, vous verrez breakevens à des seuils inférieurs.

Mais la réalité est assez compliqué. Donc, jusqu'à ce que vous atteindre experthood, d'abord identifier lorsque le traitement séquentiel est réellement vous coûter quelque chose, et puis de mesurer si le parallélisme de l'aide.
- Ce post donne plus de détails sur la NQ modèle: gee.cs.oswego.edu/dl/html/StreamParallelGuidance.html
- je pense que vous avez besoin pour développer votre affirmation non-déterminisme - autant que je sache, il est strictement impossible pour un déterministe problème pour devenir non déterministe, à moins que le problème lui-même est changé - cela s'applique également aux cours d'eau, tout ce qu'ils font est d'envelopper les discussions autour de segments de itérable collections; à moins que les éléments eux-mêmes interagissent les uns avec les autres dans une écriture manière que le flux ne peut pas être non déterministe --- et si votre collection elle-même est non déterministe depuis le début, même le meilleur de/la boucle while l'habitude de changer ce fait.
- Je ne suis pas sûr de comprendre ta question -- est-ce que vous cherchez quelqu'un pour expliquer pourquoi, en parallèle de multiples threads faire le calcul nondeterminstic?
- ... non? Fils parallèles ne pas faire de rien non déterministe par eux-mêmes. Approprié algorithmes peut le faire mais c'est sur il - la technologie elle-même n'a rien à voir avec le résultat de son utilisation, c'est un non-sens complet - il est facile d'écrire du code en parallèle qui ne change pas de déterminisme, à tous les
- la commutation d'un flux séquentiel parallèle t changement de l'algorithme (dans la plupart des cas). Le déterminisme mentionné ici est en ce qui concerne les propriétés de votre (arbitraire) des opérateurs à appuyer sur (le Ruisseau de la mise en œuvre ne pouvez pas le savoir), mais bien sûr ne pas s'appuyer sur. C'est ce que la section de cette réponse essayé de dire. Si vous vous souciez de règles, vous pouvez avoir un résultat déterministe, comme vous dites, (autrement flux parallèles ont été tout à fait inutile), mais il y a aussi la possibilité de intentionnellement permis de non-déterminisme, comme lors de l'utilisation de findAny au lieu de findFirst...
- "Tout d'abord, notez que le parallélisme n'offre pas d'avantages autres que la possibilité d'une exécution plus rapide lorsque plus de cœurs sont disponibles", ou si vous êtes appliquant une action qui implique IO (par exemple myListOfURLs.stream().map((url) -> downloadPage(url))...).
- puisque vous êtes la langue de concepteur, vous devez prendre garde à ceci: Toujours utiliser le parallélisme chaque fois que l'algorithme est donc sémantiquement. Parce que même en séquentiel est plus rapide lorsque NQ-dessous de 10k, la différence serait si petit qu'il n'a pas d'importance de toute façon. Pourtant, si NQ est au-dessus et bien au-dessus de 10k, le parallélisme est le seul moyen.
- En effet, un autre point positif à cela est la justesse sémantique. On devrait marquer parallélisables code parallélisables et laisser le compilateur pour mesurer si elle doit le faire en parallèle ou non. C'est exactement la même ligne d'argumentation de choisir if vs switch: utilisez simplement selon ce qui est sémantiquement correct, et laisser le compilateur de déterminer la meilleure façon de appliquer il.
- C'est une belle théorie, mais, malheureusement, naïve (voir l'histoire de 30 ans de tentatives pour construire l'auto-parallélisation de compilateurs pour commencer). Car il n'est pas possible de deviner juste assez de temps pour ne pas ennuyer l'utilisateur lorsqu'il est inévitable d'avoir tort, la chose responsable à faire, c'était juste pour permettre à l'utilisateur de dire ce qu'ils veulent. Pour la plupart des situations, la valeur par défaut (séquentiel) est à droite, et de plus en plus prévisible.
- Ne jamais utiliser de flux parallèles pour IO. Elles sont destinées uniquement pour le CPU opérations intensives. Flux parallèles utilisation ForkJoinPool.commonPool() et vous ne voulez pas de blocage des tâches d'y aller.
- Dans NQ modèle vous avez écrit: "Q est le calcul par élément" que signifie-t-il, c'est le temps nécessaire pour calculer un élément? Comment dois-je calculer Q?
InformationsquelleAutor Brian Goetz
50

J'ai regardé un des présentations de Brian Goetz (Langage Java Architecte & spécification de plomb pour les Expressions Lambda). Il explique en détail la suite de 4 points à prendre en considération avant d'aller à la parallélisation:

Découpage /décomposition des coûts

– Parfois, le fractionnement est plus cher que de simplement faire le travail!

Tâche la répartition /gestion des coûts

– On peut faire beaucoup de travail dans le temps de travail à la main à un autre thread.

Résultat de la combinaison des coûts

– Parfois, la combinaison implique la copie de beaucoup de données. Par exemple, l'ajout de numéros n'est pas cher alors que la fusion des ensembles est cher.

Localité

– L'éléphant dans la pièce. C'est un point important qui tout le monde peut manquer. Vous devriez considérer les défauts de cache, si un CPU attend les données en raison de défauts de cache alors que vous ne voudriez pas de gagner quoi que ce soit par la parallélisation. C'est pourquoi la matrice de sources paralléliser le meilleur comme le prochain indices (près de l'actuel indice) sont mises en cache et il y a peu de chances que le CPU ferait l'expérience d'un cache miss.

Il mentionne également relativement simple formule pour déterminer une chance de parallèle speedup.

NQ Modèle:
```
N x Q > 10000
```
où,

N = nombre d'éléments de données

Q = quantité de travail par poste
- Brian a fait une réponse à cette question 🙂
InformationsquelleAutor Ram Patra
11

JB a frappé le clou sur la tête. La seule chose que je peux ajouter, c'est que Java 8 ne fait pas un pur traitement parallèle, il ne paraquential. Oui j'ai écrit l'article et j'ai fait des F/J pendant trente ans, donc, je ne comprends le problème.
- Les flux ne sont pas itérable car les ruisseaux ne itération interne plutôt qu'externe. C'est la raison pour laquelle l'ensemble pour les cours d'eau de toute façon. Si vous avez des problèmes avec le travail universitaire, puis de la programmation fonctionnelle peut-être pas pour vous. Programmation fonctionnelle === math === scolaire. Et non, J8-FJ n'est pas cassé, c'est juste que la plupart des gens ne lisent pas les f****** manuel. La java docs disent très clairement que ce n'est pas une exécution parallèle cadre. C'est la raison pour laquelle l'ensemble de tous les spliterator choses. Oui, c'est académique, oui, il fonctionne si vous savez comment l'utiliser. Oui, il devrait être plus facile d'utiliser un exécuteur personnalisé
- Stream a un iterator() la méthode, de sorte que vous pouvez réitérer externe si vous le souhaitez. Ma compréhension est qu'ils n'implémentent pas Itérable parce que vous ne pouvez utiliser que l'itérateur une fois et personne ne pouvait décider que c'était OK.
- pour être honnête : la totalité de votre document se lit comme un massif, d'élaborer coup de gueule - et c'est à peu près nie sa crédibilité ... je vous recommande de la refaire avec un bien moins agressif nuance, sinon, pas beaucoup de gens vont réellement pris la peine de lire entièrement ... il im juste sayan
- Un couple de questions au sujet de votre article... tout d'abord, pourquoi avez-vous apparemment assimiler équilibré structure d'arbre dirigé acyclique graphiques? Oui, équilibré arbres est DAGs, mais les listes chaînées et à peu près chaque structure de données orientée objet autre que des tableaux. Aussi, quand vous dites décomposition récursive ne fonctionne que sur l'équilibre entre la structure d'arbre et n'est donc pas pertinent commercialement, comment justifiez-vous cette affirmation? Il me semble (il est vrai sans vraiment l'examen de la question en profondeur) que cela devrait fonctionner tout aussi bien sur le tableau à base de structures de données, par exemple ArrayList/HashMap.
- Ce fil est à partir de 2013, beaucoup de choses ont changé depuis. Cette section est pour les commentaires pas de réponses détaillées.
InformationsquelleAutor edharned
1

D'autres réponses ont déjà couvert de profilage pour éviter l'optimisation prématurée et des frais généraux dans le traitement en parallèle. Cette réponse explique le choix idéal pour les structures de données parallèles en streaming.

En règle générale, les gains de performance de parallélisme sont les meilleurs sur les cours d'eau ArrayList , HashMap , HashSet , et ConcurrentHashMap instances; les tableaux; int des plages; et long plages. Ce que ces structures de données ont en commun est qu'ils peuvent tous être avec précision et à moindre coût divisé en sous-plages de toutes les tailles souhaitées, ce qui le rend facile de répartir le travail entre threads parallèles. L'abstraction utilisée par les ruisseaux de la bibliothèque pour effectuer cette tâche est la spliterator , qui est retourné par la spliterator méthode sur Stream et Iterable.

Un autre facteur important que l'ensemble de ces structures de données ont en commun est qu'ils fournissent de bonne à excellente localité de référence, lorsqu'elles sont traitées de manière séquentielle: séquentiel élément références sont stockées dans la mémoire. Les objets visés par ces références peuvent ne pas être à proximité l'un de l'autre dans la mémoire, ce qui réduit la localité de référence. Localité de référence s'avère extrêmement important pour la parallélisation des opérations en bloc: sans elle, les threads passent beaucoup de leur temps d'inactivité, en attente pour le transfert de données à partir de la mémoire dans le cache du processeur. Les structures de données avec le meilleur site de référence sont primitives parce que les tableaux de données lui-même est stocké de manière contiguë en mémoire.

Source: Item #48 user de Prudence Lors de la Prise de Flux Parallèle, Efficace Java 3e par Joshua Bloch

InformationsquelleAutor ruhong

Vous devez vous connecter pour publier un commentaire.