Comment mettre à l'échelle les threads en fonction des cœurs de processeur?

Je souhaite résoudre un problème mathématique avec plusieurs threads en Java. mon problème mathématique peut être séparé en unités de travail, que je souhaite résoudre en plusieurs threads.

Je ne veux pas avoir un nombre fixe de threads qui y travaillent, mais plutôt une quantité de threads correspondant à la quantité de cœurs de processeur. Mon problème est que je n'ai pas trouvé de tutoriel facile sur Internet pour cela. Tout ce que j'ai trouvé, ce sont des exemples avec des fils fixes.

Comment cela peut-il être fait? Pouvez-vous donner des exemples?

Vous pouvez déterminer le nombre de processus disponibles sur la machine virtuelle Java à l'aide de la méthode statique Runtime, availableProcessors . Une fois que vous avez déterminé le nombre de processeurs disponibles, créez ce nombre de threads et divisez votre travail en conséquence.

Mise à jour : pour clarifier davantage, un thread n'est qu'un objet en Java, vous pouvez donc le créer comme vous le feriez pour tout autre objet. Donc, disons que vous appelez la méthode ci-dessus et constatez qu'elle renvoie 2 processeurs. Impressionnant. Maintenant, vous pouvez créer une boucle qui génère un nouveau thread, divise le travail pour ce thread et déclenche le thread. Voici quelques psuedocode pour démontrer ce que je veux dire:

int processors = Runtime.getRuntime().availableProcessors();
for(int i=0; i < processors; i++) {
  Thread yourThread = new AThreadYouCreated();
  // You may need to pass in parameters depending on what work you are doing and how you setup your thread.
  yourThread.start();
}

Pour plus d'informations sur la création de votre propre fil de discussion, consultez ce didacticiel . En outre, vous souhaiterez peut-être consulter Thread Pooling pour la création des threads.

Vous voudrez probablement regarder le framework java.util.concurrent pour ce genre de choses aussi. Quelque chose comme:

ExecutorService e = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
// Do work using something like either
e.execute(new Runnable() {
        public void run() {
            // do one task
        }
    });

ou

    Future<String> future = pool.submit(new Callable<String>() {
        public String call() throws Exception {
            return null;
        }
    });
    future.get();  // Will block till result available

C'est beaucoup plus agréable que de gérer vos propres pools de threads, etc.

Option 1:

nouveauWorkStealingPool deExecutors

public static ExecutorService newWorkStealingPool()

Crée un pool de threads volants en utilisant tous les processeurs disponibles comme niveau de parallélisme cible.

Avec cette API, vous n'avez pas besoin de transmettre le nombre de cœurs à ExecutorService.

Implémentation de cette API depuis grepcode

/**
     * Creates a work-stealing thread pool using all
     * {@link Runtime#availableProcessors available processors}
     * as its target parallelism level.
     * @return the newly created thread pool
     * @see #newWorkStealingPool(int)
     * @since 1.8
     */
    public static ExecutorService newWorkStealingPool() {
        return new ForkJoinPool
            (Runtime.getRuntime().availableProcessors(),
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }

Option 2:

API newFixedThreadPool de Executorsou other newXXX constructors, qui renvoieExecutorService

public static ExecutorService newFixedThreadPool(int nThreads)

remplacer nThreads par Runtime.getRuntime().availableProcessors()

Option 3:

ThreadPoolExecutor

public ThreadPoolExecutor(int corePoolSize,
                      int maximumPoolSize,
                      long keepAliveTime,
                      TimeUnit unit,
                      BlockingQueue<Runnable> workQueue)

passer Runtime.getRuntime().availableProcessors()en paramètre à maximumPoolSize.

Doug Lea (auteur du package concurrent) a cet article qui peut être pertinent: http://gee.cs.oswego.edu/dl/papers/fj.pdf

Le framework Fork Join a été ajouté à Java SE 7. Voici quelques références supplémentaires:

http://www.ibm.com/developerworks/java/library/j-jtp11137/index.html Article de Brian Goetz

http://www.oracle.com/technetwork/articles/java/fork-join-422606.html

La méthode standard est la méthode Runtime.getRuntime (). AvailableProcessors (). Sur la plupart des processeurs standard, vous aurez renvoyé ici le nombre de threads optimal (qui n'est pas le nombre réel de cœurs de processeur). C'est donc ce que vous recherchez.

Exemple:

ExecutorService service = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

N'oubliez PAS d'arrêter le service exécuteur comme ceci (ou votre programme ne se fermera pas):

service.shutdown();

Voici juste un bref aperçu de la configuration d'un futur code MT (hors-sujet, à titre d'illustration):

CompletionService<YourCallableImplementor> completionService = 
    new ExecutorCompletionService<YourCallableImplementor>(service);
    ArrayList<Future<YourCallableImplementor>> futures = new ArrayList<Future<YourCallableImplementor>>();
    for (String computeMe : elementsToCompute) {
        futures.add(completionService.submit(new YourCallableImplementor(computeMe)));
    }

Ensuite, vous devez suivre le nombre de résultats attendus et les récupérer comme suit:

try {
  int received = 0;
  while (received < elementsToCompute.size()) {
     Future<YourCallableImplementor> resultFuture = completionService.take(); 
     YourCallableImplementor result = resultFuture.get();
     received++; 
  }
} finally {
  service.shutdown();
}

Sur la classe Runtime, il existe une méthode appelée availableProcessors (). Vous pouvez l'utiliser pour déterminer le nombre de processeurs dont vous disposez. Puisque votre programme est lié au CPU, vous voudrez probablement avoir (au plus) un thread par CPU disponible.