Courir le 100 threads en parallèle et courir manquant fils si certains sont finis

Par exemple, j'ai besoin de toujours courir le 100 threads pour faire une action.
J'ai une classe appelée ThreadsWorker qui cherche les fils de comte et pistes manquantes threads si certains sont finis.
Donc, c'est le tableau qui décrit la situation:

1 second: 100 threads
2 second: 92 threads (ThreadsWorker generates new 8 threads)
3 second: 100 theads
4 second: 72 threads (ThreadsWorker generates 28 threads)

Et ainsi de suite.
Mes fils sont des appels anonymes (juste new Thread(new Runnable(...)).start()) parce que je ne sais pas comment faire pour enregistrer correctement à Threads[] tableau car, tandis que ThreadsWorker permettra d'économiser threads[i] = new Threads(), certains threads peut être fini, et puis il y aura des collisions avec les indices de tableau.

Parce que des appels anonymes-je utiliser threadsCount variable est maintenant et l'incrémenter dans les threads corps de début et diminue dans les fils d'extrémité du corps (à l'aide de synchronized). Ok, il fonctionne correctement et que mon seul moyen est d'utiliser while() boucle qui vérifie si threadsCount == 0 lorsque l'opération est terminée.

Je pense que c'est en C mais pas en Java 🙂 oui, pouvez-vous m'aider à le faire en Java?

OriginalL'auteur Clark | 2011-04-01

  1. 6

    Si votre objectif est simplement d'avoir 100 threads activement traitement, je vous suggère de regarder Java les pools de threads (et Les exécuteurs plus généralement).

    Je suis pas clair quant à savoir si vous voulez garder tous les threads 100 à l'aller ou attendre qu'elles soient toutes à la fin. Votre question fait référence à la fois (ThreadsWorker frai 28 nouveaux threads, threadsCount==0) et ils semblent contradictoires.

    +1 pour l'utilisation de la simultanéité utils pour cela, plutôt que brut de threads. Voir ma réponse ici pour un peu de code réutilisable. stackoverflow.com/questions/5115940/...
    Donc, si je vais utiliser «newFixedThreadPool()» alors, je vais devraient utiliser certains Travailleurs qui permettra de créer de nouveaux threads à cette file d'attente pour piscine infinitly?

    OriginalL'auteur Michael Brewer-Davis

  2. 5

    Mettre tous les threads dans un tableau ou d'une collection.

    Ensuite une boucle à travers la collection Thread appelant.join() sur chacun d'eux. Lorsque cette boucle est terminée, tous les threads sont fait.

    ArrayList threads = new ArrayList();
for (int i = 0; i < 5; i++) {
  Thread t = new AweseomeThread();
  t.start();
  threads.add(t);
}

for (Thread t : threads) {
  t.join();
}

    Vous aurez besoin d'une gestion des exceptions (telles que InterruptedException). Mais, je vais laisser ça comme un exercice pour le lecteur... 🙂

    Yep, je sais à propos de joindre la méthode et des exceptions 🙂 Mais je ne sais pas comment faire pour travailler correctement avec les index et les fils de tableau dans cette situation. Je veux dire, si je vais le laisser quelques indices de vides à cause de ThreadsWorker pense que threadsCount = 15 mais alors qu'il va fonctionner&enregistrer les threads descripteurs de quelque autre fils va mourir et f.e. threads[71] et fils[75] sera avec descriptos mais threads[72] fils[74] vide descripteurs. Donc je vais devoir faire une pause tous les threads alors que ThreadsWorker permettra d'économiser des index de tableau pour éviter de vider les indices?
    Je serais probablement conseillons de ne pas essayer d'utiliser un tableau, mais l'utilisation d'une collection à la place. Maintenant que vous le dites et que j'ai re-lu votre question, j'ai mal compris. Je pensais que tu voulais juste savoir, lorsque tous les threads ont été complète, mais il semble que vous voulez garder 100 fils vivant. J'ai une autre idée... je vais présenter comme une réponse distincte, bien que pour la clarté et dans le cas où je suis encore à l'incompréhension de votre question.

    OriginalL'auteur squawknull

  3. 3

    http://download.oracle.com/javase/6/docs/api/java/util/concurrent/CountDownLatch.html

    Vous pouvez essayer de classe CountDownLatch de l'api du jdk

    private CountDownLatch latch;
private static class SimpleThread extends Thread {
 public void run() {
  latch.countDown();
 }
}
public static void main(String[] args) {
 int threadcount = 10;
 latch = new CountDownLatch(threadcount);
 for (int i = 0; i < 10; i++) {
  Thread t = new SimpleThread();
  t.start();
 }
 //waiting threads all finished
 latch.await();
}

    Récupérer le nombre de threads d'attribut latch de la classe Principale

    Je pense que c'est pour l'attente pour une opération donnée dans un autre thread à la fin, mais l'affiche a demandé d'attendre pour le fil d'arrivée et de retour, à droite? Ne pas passer le Fil.join () - être plus approprié dans son cas?
    CountDownLatch peut aider pour l'attente, tous les threads fini, et cache la quantité de threads.
    Merci, j'ai lu aujourd'hui sur CountDownLatch mais je pense que c'est tellement énorme pour mon travail (joindre méthode géniale pour cela, mais j'ai quelques problèmes avec tableau indexé). Et peut-être un peu correct. Mais merci quand même!
    > «aide Principale pour l'attente, tous les threads fini, et cache les fils de compter les» O! Pouvez-vous montrer à l'échantillon? Après je pense que ce est plus bon pour ma situation.
    j'ai donc mettre à jour un exemple dans mon post

    OriginalL'auteur store88

  4. 2

    Je crois que l'on cherche à faire ThreadWorker présenter les nouveaux threads pour tous les threads qui ont été achevés.

    J'avais utiliser un BlockingQueue que les fils (Votre Exécutable(s)) ajouter à la fin. ThreadWorker va attendre jusqu'à ce qu'un thread se termine puis va commencer un nouveau thread.

    public class YourRunnable implements Runnable {
  private final BlockingQueue<YourRunnable> queue;
  public YourRunnable(BlockingQueue<YourRunnable> queue){
    this.queue = queue;
  }
  public void run{
      //Your Code...
      //Finished Processing
      queue.add(this);
  }
}
public class ThreadWorkder implements Runnable { 
  private final BlockingQueue<YourRunnable> queue;
  ThreadWorker(BlockingQueue<YourRunnable> queue){
    this.queue = queue;
  }
  public void run{
    while(queue.take()){
       (new Thread(new YourRunnable(queue))).start();
    }
  }
  //general main method
  public static void main(String [] args){
    BlockingQueue<YourRunnable> queue = new LinkedBlockingQueue<YourRunnable>();
    ThreadWorker worker = new ThreadWorker(queue);
    Thread(worker).start();
    for (int i = 0; i < 100; i++){
      (new Thread(new YourRunnable(queue))).start();
    }
  }
}

    OriginalL'auteur richs

  5. 1

    Utiliser une collection au lieu d'un tableau. Comme les fils sont terminé, demandez-leur de se retirer de la matrice. Quelque chose comme ceci:

    public class Foo {
  Vector<Thread> threads = new Vector<Thread>(); //Vector is threadsafe

  public ensureThreadCount(int count) {
    while (threads.size() < count) {
      Thread t = new AweseomeThread(threads);
      threads.add(t);
      t.start();
    }
  }
}

public class AwesomeThread {
  Collection threads;
  public AwesomeThread(Collection threads) {
    this.threads = threads;
  }

  public void run() {
    try {
      //do stuff
    } catch (Throwable t) {
    } finally {
      threads.remove(this);
    }
  }
}

    Ensuite, demandez à vos travailleurs à seulement appeler Foo.ensureThreadCount().

    OriginalL'auteur squawknull