Bonjour à tous    
 
J'utilise le logiciel processing pour un projet ainsi que la librairie Fisica (http://www.ricardmarxer.com/fisica/)
Lorsque j'utilise processing, je vois avec le gestionnaire des taches qu'il utilise un seul coeur (il est donc limité à 25% vu que j'ai 4 coeurs). J'aimerais donc savoir s'il est possible d'utiliser processing sur plusieurs coeurs histoire d'optimiser le truc ?

Je ne suis pas un spécialiste mais je sais que la seule façon d'utiliser plusieurs core est de faire du multi threading.
Je ne connais pas Processing ni Fisica, je ne sais pas si ils sont compatibles,
mais attention aux problèmes de concurrence, thread-safe et toute la cavalerie des problèmes de données partagées et de thread qui s'attendent.
 
 
Runtime.getRuntime().availableProcessors() permet de voir le nombre de cores vus par la jvm

J'ai fais une recherche sur google avec "Runtime.getRuntime().availableProcessors()" et je suis tombé sur ça http://forum.processing.org/two/di [...] -system/p1. En gros le gars divise le boulot à faire en taches avec une tache sur chaque coeur (fin si j'ai bien compris).
Je vais essayer de mettre ça dans mon programme, je vous tiens au courant

Si je regarde les javadocs des dépendances en import
http://docs.oracle.com/javase/7/do [...] lable.html
The Callable interface is similar to Runnable, in that both are designed for classes whose instances are potentially executed by another thread
 
http://docs.oracle.com/javase/7/do [...] cutor.html
An object that executes submitted Runnable tasks
 
je pense que c'est du multi-thread wrappé à la mode java <version récente> ... ça présente bien en tous cas.
Attention, l'auteur demande des conseils pour améliorer l'efficacité, il ne dit pas que son programme fonctionne.

Est-ce que tu serais capable de m'expliquer son programme ? J'avoue que j'ai un peu de mal à le comprendre    
Sinon j'ai testé son programme, c'est pas optimal mais il fonctionne quand même sur plusieurs coeurs.

 
Le gars a 1 million de particules dont il veut calculer les couleurs et je ne sais quoi. Dans un tableau particles[1000000]
Le nombre justifie de paralléliser le travail en tâches.
 
Il calcule availableProcessors donc il connait le nombre de particules par tâche particlesPerTask = 1E6 / availableProcessors;  
 
Enfin, il déclare une liste de tâches : tasks = new ArrayList<Task>(); et y ajoute des Task.
Les Tasks parallélisent le calcul du tableau de particules, chacune sait ou démarrer et ou s'arrêter dans le tableau particles[] grâce aux paramètres du constructeur de Task.
 
Chaque Task calcule les couleurs des Particle en fonction des mouvements souris.
 
Le top départ semble donner par le executorService.invokeAll(tasks);
Comme chacune des Task de tasks sont Callable, j'imagine que toute la mécanique qui va bien se déroule grâce aux bonnes implémentations (cela sert à cela).  
 
NB1 : l'exemple est trop facile, deux tâches ne gèrent jamais la même donnée particles[p], ce qui créerait des problèmes de concurrence et serait proches d'exemples concrets.
NB2 : A priori chaque Task va réagir de même manière aux mouvements de la souris, et calculer les mêmes couleurs, je ne vois pas l’intérêt fonctionnel du bout de code ... du traitement graphique ... ou un simple exercice de style.