Java: Est - `while (true) { ... } " en boucle dans un thread de mauvais? Quelle est l'alternative?

Est while (true) { ... } boucle dans les threads mauvais? Quelle est l'alternative?

Mise à jour; ce que j'essaie de...

J'ai ~de 10 000 threads, chacun de consommer les messages de leurs files d'attente privées. J'ai un thread qui produit des messages un par un et de les mettre dans la bonne file d'attente du consommateur. Chaque thread consommateur est en boucle, la vérification d'un message s'affiche dans la file d'attente et de la traiter.

À L'Intérieur Consumer.java:

@Override
public void run() {
    while (true) {
        Message msg = messageQueue.poll();
        if (msg != null) {
            ... //do something with the message
        }
    }
}

Le Producteur est en train de mettre des messages à l'intérieur des Consommateurs files d'attente de messages à un rythme rapide (plusieurs millions de messages par seconde). Les consommateurs devraient traiter ces messages aussi vite que possible!

Remarque: le while (true) { ... } est terminée par un KILL message envoyé par le Producteur de son dernier message. Cependant, ma question est sur la bonne façon de le faire ce passage de message...

Veuillez voir la nouvelle question, au sujet de cette conception.

Pourquoi ne pas vous donner plus de détails sur ce que vous essayez d'atteindre et nous allons vous dire si il y a une meilleure façon de le faire.
@Ryan: Mis à jour; s'il vous plaît prendre un coup d'oeil!
10000 fils semble être une mauvaise idée, car il peut y avoir des frais généraux associés à chaque thread...
@Colen: Veuillez voir ma nouvelle question, car je pensais que c'était une mauvaise idée aussi... Quelle est l'alternative? stackoverflow.com/questions/3367383/...
La surcharge de 10k threads de l'extrême
Willi Schönborn: Alors, quelle est l'alternative?
si vous utilisez un certain temps au lieu d'une instruction if à l'intérieur de votre thread - est-ce à dire que vous créez une nouvelle boucle à chaque fois que votre thread s'exécute?

InformationsquelleAutor Mr. Burgundy | 2010-07-29

17

Au lieu de boucle pour toujours et de le casser ou de retour, vous pouvez choisir de vérifier l'état d'interruption.
```
while (!Thread.currentThread().isInterrupted()) {
    try {
        doWork();
        wait(1000);
    } catch (InterruptedException ex) {
        Thread.currentThread().interrupt();
    }
}
```
Si vos fils sont des tâches gérées par un ExecutorService, vous pouvez les avoir tous en fin gracieusement simplement en appelant shutdownNow().
- Mieux utiliser Thread.sleep(1000) que d'attendre(), cz attendre nécessite l'objet à être bloqué à la première.
- Hey. C'est gentil... Mais si je veux tuer le thread de update méthode d'un observateur... je ne sais pas combien de temps cela va prendre pour déclencher la méthode de manière aléatoire wait(1000) ne marchera pas ici....
InformationsquelleAutor JRL
8
```
while (!stop_running) { ... }
```
...peut-être? Une certaine sorte de sortir le drapeau est souvent utilisée pour contrôler le thread en cours d'exécution.
- Si vous faites cela, assurez-vous que stop_running utilise le mot clé volatile. Voir Java de la Simultanéité Dans la Pratique, la section 7.1.
- cela semble simple, mais la question: comment stop_running changement à false, une fois que la boucle commence? C'est ce que je pense que la plupart des gens se demandent
InformationsquelleAutor souser12345
8

Pas, en soi, pas. Vous pouvez toujours en liberté sous caution à l'aide de break ou return. Assurez-vous de réellement faire (à un point)

Le problème est ce qui se passe quand votre fils n'a rien à faire? Si vous venez de faire une boucle autour et autour de la vérification d'une condition, votre thread va manger toute la CPU ne rien faire. Donc, assurez-vous d'utiliser wait à cause de votre fil pour bloquer, ou sleep si vous n'avez pas de quoi wait sur.
- Est-il vraiment beaucoup de CPU si?
- essayez-le vous-même, mais oui, je crois qu'une longue attente serait d'utiliser 100% d'un cœur de PROCESSEUR.
- Ceci est appelé occupé de la boucle et utilise toute la puissance du processeur, il peut obtenir à partir d'un seul cœur. Dans l'ancien temps, où le cpu uniquement a un seul core, ce qui pourrait entraîner votre système à ses genoux, et les développeurs donc grandement bénéficié de deux cpu système.
InformationsquelleAutor Eric Petroelje
3

Dépend de la définition de "mauvais". Cela signifie que la personne en essayant de lire le code est à chercher ailleurs pour la raison que la boucle se termine. Qui peut le rendre moins lisible.

Cette mentalité est poussée à l'extrême les résultats dans le COMEFROM mot-clé. http://en.wikipedia.org/wiki/COMEFROM
```
10 COMEFROM 40
20 INPUT "WHAT IS YOUR NAME? "; A$
30 PRINT "HELLO, "; A$
40 REM
```
- 100 upvotes..(y) pour le terme COMEFROM
InformationsquelleAutor Thorbjørn Ravn Andersen
1

Il est préférable d'avoir de la résiliation de la condition sur la while (...) ligne, mais parfois la résiliation condition est quelque chose que vous ne pouvez tester quelque part profondément à l'intérieur de la boucle. Alors qu'est ce que break est pour la (ou des exceptions). En fait, peut-être que votre fils doit toujours courir jusqu'à ce que votre programme se termine (avec System.exit); puis while (true) est vraiment le droit.

Mais peut-être que vous vous dites à propos de ce qu'il devrait aller à l'intérieur de la boucle. Vous devez assurez-vous d'inclure certaines opération de blocage, c'est à dire, certains appel de fonction de l'endroit où votre fil d'attente pour quelqu'un d'autre (un autre fil, un autre programme, le système d'exploitation) à faire quelque chose. C'est typiquement Condition.wait si vous êtes à la programmation avec des serrures, ou par la lecture d'un message de la file d'attente, ou par la lecture d'un fichier ou d'une prise réseau, ou d'un autre blocage I/O operation.

Noter que sleep est généralement pas assez bon. Vous ne pouvez pas savoir quand les autres participants vont faire quelque chose, donc il n'y a aucun moyen d'éviter de se réveiller trop souvent (et donc de brûler plus de temps CPU inutilement) ou trop rarement (donc pas de réagir aux événements en temps opportun). Toujours la conception de votre système de sorte que lorsqu'un thread a terminé son travail, il le notifie à celui qui est en attente sur ce travail (souvent avec Condition.signal ou par adhésion).

InformationsquelleAutor Gilles
0

Généralement, vous aurez envie de wait sur une ressource d'un certain type pour faire le travail, qui cache réelle de filetage de détails auprès de vous. On dirait que tu voulais mettre en place votre propre spinlock.

Voici un tutoriel sur le verrouillage, j'ai trouvé que je google.

InformationsquelleAutor Stefan Kendall
0

J'ai l'habitude d'aller avec un attribut de classe boolean appelé "terminé", puis le fils exécuter les méthodes de ressembler à
```
done = false;
while( !done ) {
    //... process stuff
}
```
Vous pouvez ensuite définir done=true pour tuer la boucle. Cela peut être fait à partir de l'intérieur de la boucle, ou vous pouvez avoir une autre méthode qui définit, alors que d'autres threads peuvent tirer la prise.

InformationsquelleAutor JustJeff
0

while (true) n'est pas mauvais, si il ya un moyen de sortir de la boucle sinon, l'appel sera exécuté indéfiniment.

Pour 10000 threads faire la while(true) appel est une mauvaise pratique...pourquoi ne pas avoir un sleep() sur le fil pour permettre à d'autres threads de s'exécuter ou d'une stratégie de sortie si le fil de fin de l'exécution?

InformationsquelleAutor Buhake Sindi
0

On dirait que vous êtes occupé attente, en supposant un standard BlockingQueue. Utilisation take au lieu de poll.

Autre que cela, for (;;) est plus agréable que de while (true), de l'OMI.
- l'aide va garder en attente pour le message d'? et sondage(100) va juste attendre pendant 100 ms et de continuer l'exécution. Donc, ce n'est pas un sondage(100) mieux que prendre?
InformationsquelleAutor Tom Hawtin - tackline
0

D'abord, la réponse à ce problème en Pâte Lea:

Il n'est presque jamais une bonne idée d'utiliser nue tours d'attente pour des valeurs de variables. L'Utilisation De La Thread.onSpinWait, Fil.le rendement et/ou de blocage de synchronisation afin de mieux composer avec le fait que "finalement" peut être longue, surtout quand il y a plus de threads que de cœurs sur un système.

http://gee.cs.oswego.edu/dl/html/j9mm.html

Thead.onSpinWait a été introduit avec Java 9. Il pourrait ressembler à ceci.
```
while (true) {
    while (messageQueue.peek() == null) {
       Thread.onSpinWait();
    }
    //do something with the message
}
```
Par l'invocation de cette méthode au sein de chaque itération d'un spin-boucle d'attente construire, le thread appelant indique à l'exécution qu'elle est occupée d'attente. Le moteur d'exécution peut prendre des mesures pour améliorer la performance de l'invocation de la spin-boucle d'attente des constructions.

https://docs.oracle.com/javase/9/docs/api/java/lang/Thread.html#onSpinWait--

InformationsquelleAutor Fritz Duchardt
-1

Si je devais faire ce que vous parlez, je voudrais essayer ceci:
```
private Object lock = new Object();    

public void run(){
    while(true){
        synchronized(lock){
            Message msg = messageQueue.poll();
            if (msg != null) {
                ... //do something with the message
            }else{
                try{
                    lock.wait();
                }catch(InterruptedException e){
                    e.printStackTrace();
                    continue;
                }
            }
        }
    }
}
```
Cela vous permet de vous assurer que vous n'obtenez pas de modifications simultanées exepction sur votre messageQueue, ainsi que lorsqu'il n'y a pas de message, vous ne serez pas en utilisant le temps CPU dans le while(true) en boucle. Maintenant, vous avez juste besoin de faire en sorte que lorsque vous ajoutez quelque chose à votre messageQueue vous pouvez appeler lock.notifyAll() de sorte que le fil sera de savoir afin d'utiliser de nouveau.
- Ce n'est pas si grand avec une file d'attente partagée.
- Utilisation LinkedBlockingQueue pour la messageQueue et il wil être thread-safe, pas besoin de le verrouiller ou synchronisé bloc ci-dessus. Appelez simplement prendre la place de sondage si vous voulez bloquer alors que la file d'attente est vide. Alternativement, vous pouvez utiliser sondage avec un délai d'attente si vous souhaitez mettre en place des délais d'attente.
- Aussi avaler le interrompu exception signifie que votre fils ne peut jamais quitter, à moins qu'une RuntimeException se produit.
InformationsquelleAutor heater

Vous devez vous connecter pour publier un commentaire.