web-dev-qa-db-fra.com

Java prend-il en charge les processeurs multicœurs / traitement parallèle?

Je sais que maintenant que la plupart des processeurs ont deux cœurs ou plus, la programmation multicœur fait fureur. Existe-t-il des fonctionnalités pour utiliser cela en Java? Je sais que Java a une classe Thread, mais je sais aussi que cela remonte à longtemps avant que les multicœurs ne deviennent populaires. Si je peux utiliser plusieurs cœurs en Java, quelle classe/technique devrais-je utiliser? utilisation?

javamultithreadingparallel-processingmulticore
36
Rafe Kettler

Java prend-il en charge les processeurs multicœurs/traitement parallèle?

Oui. Il a également été une plate-forme pour d'autres langages de programmation où l'implémentation a ajouté un argument de vente "vrai multithreading" ou "réel threading". G1 Garbage Collector introduit dans les nouvelles versions utilise également du matériel multicœur.

Concurrence Java en pratique

Essayez d'obtenir une copie du livre Java Concurrence in Practice.

Si je peux utiliser plusieurs cœurs en Java, quelle classe/technique utiliserais-je?

Java.util.concurrent

Classes utilitaires couramment utilisées dans programmation simultanée . Ce package comprend quelques petits frameworks extensibles standardisés, ainsi que certaines classes qui fournissent des fonctionnalités utiles et sont par ailleurs fastidieuses ou difficiles à implémenter. Voici une brève description des principaux composants.

Exécuteurs

Executor est une interface standardisée simple pour définir des sous-systèmes de type thread personnalisés, y compris des pools de threads, des E/S asynchrones et des frameworks de tâches légers.

Files d'attente

La classe Java.util.concurrent ConcurrentLinkedQueue fournit une file d'attente efficace et évolutive non bloquante pour les threads FIFO.

Calendrier

La classe TimeUnit fournit plusieurs granularités (y compris les nanosecondes) pour spécifier et contrôler les opérations basées sur le délai d'expiration. La plupart des classes du package contiennent des opérations basées sur des délais d'attente en plus des attentes indéfinies.

Synchroniseurs

Quatre classes facilitent les idiomes de synchronisation à usage spécial communs. Semaphore est un outil de concurrence classique. CountDownLatch est un utilitaire très simple mais très courant pour bloquer jusqu'à ce qu'un certain nombre de signaux, d'événements ou de conditions se maintiennent. [...]

Collections simultanées

Outre Queues, ce package fournit quelques implémentations Collection conçues pour être utilisées dans des contextes multithreads: ConcurrentHashMap, CopyOnWriteArrayList et CopyOnWriteArraySet.

Cela est également utile si vous souhaitez faire correspondre le nombre de threads au nombre de CPU disponibles, par exemple:

int n = Runtime.getRuntime().availableProcessors();
42
bakkal

Dans la plupart des implémentations Java, vous pouvez compter sur Java étant de vrais threads OS. Par conséquent, le système d'exploitation veillera à ce que la charge de travail est distribué sur plusieurs cœurs si vous utilisez la classe Thread.

Les threads du système d'exploitation sont antérieurs aux systèmes multicœurs de base depuis longtemps, donc ce n'est pas vraiment un problème. La seule différence entre les systèmes multicœurs était de permettre aux threads du système d'exploitation à multiplexage temporel d'être exécutés en tant que threads réellement concurrents sur plusieurs cœurs.

9
Gian

Java 5 a introduit le package Java.util.concurrent qui aide à créer des applications simultanées pouvant bénéficier de systèmes multicœurs. Ce package va bien au-delà de la fonctionnalité de multithreading offerte dans Java 1.4 et versions antérieures (comme synchronisé, attendre, notifier, etc.).

Il y a une proposition pour Java 7 d'inclure le framework Fork/Join pour faciliter l'utilisation des systèmes multicœurs.

7
Richard Kettelerij

Vous trouverez nouveau fonctionnalité dans Ateji PX, une extension de Java = langage avec des primitives parallèles inspirées du pi-calcul, très différent de la programmation des threads et tout ce qui est basé sur les threads (tâches, exécuteurs, etc.).

Le parallélisme introduit de cette façon au niveau du langage, par opposition aux bibliothèques de threads qui fournissent un accès API à un concept principalement au niveau matériel, rend la programmation multicœur beaucoup plus simple et intuitive.

Il s'agit d'une approche radicalement nouvelle de la programmation parallèle qui mérite d'être lue (avertissement: je suis le concepteur d'Ateji PX). Le livre blanc est ici: http://www.ateji.com/px/whitepapers/Ateji%20PX%20for%20Java%20v1.0.pdf .

2
Patrick Viry

Oui. Java fournit API simultanée pour bénéficier des avantages des processeurs multicœurs de la machine.

Vous pouvez obtenir le nombre de processeurs disponibles à partir de Runtime et utiliser ce nombre pour créer ExecutorService via de nombreuses API dans Executors .

Vous pouvez également utiliser ThreadPoolExecutor API pour obtenir le même résultat.

Java 8 fournit une autre API: newWorkStealingPool, qui crée ForkJoinPool en utilisant tous les processeurs disponibles. Vous n'avez pas besoin de passer le nombre de processeurs comme paramètre.

Jetez un œil à l'exemple à coder:

int processorCount = Runtime.getRuntime().availableProcessors();

ExecutorService executor1 = Executors.newFixedThreadPool(processorCount);
ExecutorService executor2 =  
                            Executors.newScheduledThreadPool(processorCount);
ExecutorService executor3 = Executors.newWorkStealingPool(); // Java-8 API
ForkJoinPool forkJoinPool = new ForkJoinPool(processorCount);

Jetez un oeil à la question connexe SE Executor:

Java's Fork/Join vs ExecutorService - quand utiliser lequel?

0
Ravindra babu