Java: Comment faire évoluer les threads en fonction de cœurs de processeur?

Question

Je ne suis pas un bon programmeur java, c'est juste mon passe-temps, mais je suis impatient d'en savoir plus que la moyenne des trucs.

Je veux résoudre un problème mathématique avec plusieurs threads en java. mon problème de maths peuvent être séparées en unités de travail, que je veux avoir résolu en plusieurs threads.

mais je ne veux pas avoir un montant fixe de threads de travail, mais plutôt un correspondant quantité de fils à la quantité de cœurs de processeur. et mon problème, c'est que je ne pouvais pas trouver un moyen facile tutoriel sur internet pour cela. tout ce que je trouve sont des exemples fixes avec des threads.

Donc, pourriez-vous m'aider avec un lien vers un bon tuturial ou pourrait me donner un facile et un bon exemple? Ce serait vraiment sympa :)

Answer 1

Vous pouvez déterminer le nombre de processus disponibles à la Machine Virtuelle Java à l'aide de la statique d'Exécution de la méthode, availableProcessors. Une fois que vous avez déterminé le nombre de processeurs disponibles, de créer un nombre de threads et de diviser votre travail en conséquence.

Mise à jour: Pour préciser davantage, un Thread est juste un Objet en Java, de sorte que vous pouvez créer, comme vous le feriez pour créer n'importe quel autre objet. Donc, disons que vous appelez la méthode ci-dessus et de trouver qu'il renvoie 2 processeurs. Génial. Maintenant, vous pouvez créer une boucle qui génère un nouveau Fil de discussion, et divise le travail hors de ce thread, et les feux du fil. 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 thread, à la tête de ce tutoriel. Aussi, vous pouvez regarder la mise en pool de Threads pour la création des threads.

Answer 2

Vous devriez regarder le java.util.simultanées cadre 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 faire face à votre propre thread, piscines etc.

Answer 3

Doug Lea (auteur de la concurrente package) a ce papier qui peuvent être utiles: http://gee.cs.oswego.edu/dl/papers/fj.pdf

La Fourche Rejoindre cadre a été ajoutée à Java SE 7. Ci-dessous sont quelques références:

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

Answer 4

Sur la classe d'Exécution, il existe une méthode appelée availableProcessors(). Vous pouvez l'utiliser pour déterminer le nombre de Processeurs que vous avez. Depuis votre programme est liée à l'UC, vous auriez probablement eu envie d'avoir (au moins) un thread par CPU disponibles.

Answer 5

merci à Jason et le reste d'entre vous, je l'ai fait

mais je n'aime pas ma façon de les rejoindre. est-il un moyen plus élégant en faisant cela?

Andreas

public class Main {
static class JoinerThread extends Thread
  {
    public int id;
    public int result;
    @Override
public void run()
{
    for(int i=0; i<999999999; i++){
        Math.pow(i,2);
    }

    result = id;
}
  }
  public static void main( String[] args ) throws InterruptedException
  {
int processors = 3;
JoinerThread threads [] = new JoinerThread[processors];
for(int i=0;i<processors;i++){
    threads[i] = new JoinerThread();
    threads[i].id = i;
    threads[i].start();
}
for(int i=0;i<processors;i++){
    threads[i].join();
    System.out.println("gnaa");
}

for(int i=0;i<processors; i++){
    System.out.println( threads[i].result );
}
  }
}