Thread étant appelé plusieurs fois

Question

J'ai un code où j'ai affaire à plusieurs threads. Un thread attend l'exécution de certains autres threads dont il dépend.

Mon code d'exécution pour le fil ressemble

public void run() { 

    for (final String name : nameList) { 
     final Thread thread = getThreadByName(name); 
     if (thread != null) { 
      while (thread.isAlive()) { 
       thread.join(); 
      } 
     } 
    } 
    //perform action 
} 

Il y a peu d'autres threads en attente pour ce thread pour terminer l'exécution dans la même méthode comme run() en appelant join() comme indiqué. Supposons que ce thread dépende de trois autres threads et qu'il attend leur exécution dans thread.join(). c'est-à-dire que la taille du nom de la liste est de 3 mais ce thread effectue une action 3 fois aussi. qui est à l'extérieur pour la boucle.

et je commence à ce fil dans une autre méthode comme

switch (element.getKey()) { 
     case A 
      thread = new Thread(action); 
      thread.setName(threadName); 
      thread.start(); 
     break; 

pour une raison quelconque (que je suis incapable de comprendre) le fil court trois fois.

Est-ce qu'il ne fonctionne que lorsque j'appelle la méthode thread.start() ou est-ce qu'il doit faire quelque chose quand d'autres threads attendent ce thread dans la méthode thread.join()? quand ce thread attend dans thread.join(), il ne devrait pas effectuer d'autres actions, non?

MISE À JOUR:

Désolé pour la question claire: Il y a une déclaration d'impression juste après la course()

run() // imprimer une boucle For

Puis, en // effectuer une action il y a une autre instruction d'impression // imprimer B

A et B sont imprimés 3 fois. La seule chose que je pense pour le numéro 3 est parce que la taille de nameList est 3.

Answer 1

Deviner: vous mettez que l'enregistrement

if (thread != null) { 
    while (thread.isAlive()) { 
    thread.join(); 
    } 
} 

dans votre code; probablement pour une raison. Dans le cas où cet appel renvoie null, vous sautez de votre boucle for; et alors vous exécuterez l'action suivante. Donc, dans le cas où cette vérification a vraiment du sens; vous devez empêcher de laisser ce niveau de boucle lorsque le thread est null.