Pourquoi est-Fil.Sommeil si dangereux

Je vois souvent mentionné que Thread.Sleep(); ne doit pas être utilisé, mais je ne peux pas comprendre pourquoi il en est ainsi. Si Thread.Sleep(); peut causer des problèmes, existe-il des solutions alternatives avec le même résultat qui serait à l'abri?

par exemple.

while(true)
{
    doSomework();
    i++;
    Thread.Sleep(5000);
}

un autre est:

while (true)
{
    string[] images = Directory.GetFiles(@"C:\Dir", "*.png");

    foreach (string image in images)
    {
        this.Invoke(() => this.Enabled = true);
        pictureBox1.Image = new Bitmap(image);
        Thread.Sleep(1000);
    }
}

Pouvez-vous indiquer les références précises? Des preuves anecdotiques ne supporte pas un argument.
Pour le deuxième paragraphe: qu'essayez-vous de réaliser? (Ou, pourquoi voulez-vous dormir?)
Un résumé du blog peut-être " n'est pas une mauvaise utilisation de Thread.sleep()'.
Je ne dirais pas que c'est nocif. Je dirais plutôt que c'est comme goto: c'est à dire il y a sans doute une meilleure solution à vos problèmes de Sleep.
Ce n'est pas exactement la même que goto, ce qui est plus comme une odeur de code que d'une conception de l'odorat. Il n'y a rien de mal avec un compilateur insertion gotos dans votre code: l'ordinateur ne peut pas se confondre. Mais Thread.Sleep n'est pas exactement la même; compilateurs ne pas insérer de cet appel, et il a d'autres conséquences négatives. Mais oui, le sentiment général, à l'aide de c'est mauvais car il n'y a presque toujours une meilleure solution est certainement correct.
c'est ce que j'allait faire 🙂 bon plus si.
Le sommeil a ses utilise, mais a été utilisé à mauvais escient* et abusé d'un lot (extrêmes 1). Je pense que c'est plus facile pour certains d'essayer de simplement l'interdire (extrêmes 2/l'autre). Cela étant dit, une combinaison de pools de threads + éléments de travail + minuteries/événements vous donnera plus de rendement au coût de codage supplémentaire de temps/lignes de code (au lieu de dormir, ce thread pourrait faire autre chose sans avoir à vous frayer un autre). Mauvaise utilisation: essayez d'exécuter l'un de ces échantillons dans une interface graphique, application, sur principal/thread d'INTERFACE utilisateur -> qui fait Dormir aussi nocif que de la dynamite lorsque vous essayez d'ouvrir une porte, mais bon, pourquoi avez-vous choisi la dynamite?
Microsoft a suggéré que le Thread.Sleep(n) est nuisible ou ne doit pas être utilisé
Pourquoi ne peut-fil.sommeil être utilisé dans un long-serveur en cours d'exécution ou gui application de vérifier périodiquement io-demandes,etc?
utilisez une minuterie ou de la planification de cadre (comme quartz.net) alors...
Tout le monde est de fournir des avis sur pourquoi les exemples ci-dessus sont mauvais, mais personne n'a fourni une version réécrite à ne pas utiliser de Fil.Sleep() qui encore accomplit le but de les exemples donnés.
Chaque fois que vous mettez sleep() dans le code (ou tests) un chiot meurt
Les réponses ici sont un peu vieux. Aujourd'hui, l'utilisation Task.Delay. Voir is-it-always-bad-to-use-thread-sleep
Pardon de mon ignorance. Quel est le but de this.Invoke(() => this.Enabled = true);?

InformationsquelleAutor Burimi | 2012-01-11

c#multithreading sleep

145

Le problème avec l'appel Thread.Sleep sont explique très succinctement ici:

Thread.Sleep a son utilisation: simulation des opérations de longue durée alors que les tests de débogage sur un thread MTA. Dans .NET il n'y a aucune autre raison de l'utiliser.

Thread.Sleep(n) moyen de bloquer le thread en cours pour au moins le nombre
de timeslices (ou thread quantums) qui peuvent se produire au sein de n
millisecondes.
La longueur d'un timeslice est différent sur différentes versions/types de
Windows et les différents processeurs et varie généralement de 15 à 30
millisecondes. Cela signifie que le fil est presque garanti à bloc pour
plus de n millisecondes. La probabilité que votre thread
re-réveiller exactement après n millisecondes est à peu près aussi impossible que
impossible, peut être. Donc, Thread.Sleep est inutile pour le calendrier de.

Threads sont une ressource limitée, ils prennent environ 200 000 cycles
pour créer et environ 100 000 cycles pour les détruire. Par défaut, ils
réserve de 1 méga-octet de mémoire virtuelle pour sa pile et l'utilisation de 2 000 à 8 000
cycles pour chaque changement de contexte. Ce qui rend l'un thread en attente d'un
énorme déchets.

La solution préférée: WaitHandles

Les plus-fait-erreur à l'aide de Thread.Sleep avec un tout-construire (démonstration et répondre à, blog de nice-entrée)

EDIT:

Je voudrais améliorer ma réponse:
Nous avons 2 différents cas d'utilisation:
1. Nous sommes en attente parce que nous savons un
  spécifique de temps, alors que nous devrions continuer (utiliser Thread.Sleep, System.Threading.Timer ou similaires)
2. Nous sommes en attente en raison des changements de condition de quelques temps ...
  mot-clé(s) est/sont un certain temps! si l'état-vérifier dans notre code de domaine, nous
  devrait utiliser WaitHandles - sinon le composant externe doit
  fournir une certaine forme de crochets ... si ce n'est pas sa conception, c'est mal!
Ma réponse couvre principalement les cas d'utilisation 2
- Je ne dirais pas 1 MO de mémoire un énorme gaspillage envisage aujourd'hui de matériel
- hey, en discuter avec l'auteur de l'original 🙂 et, cela dépend toujours de votre code - ou mieux: le facteur ... et la principale question est "Threads sont une ressource limitée" - aujourd'hui les enfants ne savent pas beaucoup sur l'efficacité et le coût de certaines mises en œuvre, parce que "le matériel est bon marché" ... mais parfois vous avez besoin de code très optd
- Sûrement, à l'aide d'un WaitHandle serait d'utiliser plus de ressources que sleep() appel?
- eh bien, WaitHandle va à la maternelle et à l'arrière (selon yoda.arachsys.com/csharp/threads/waithandles.shtml) ... atm je ne sais pas ce que Thread.Sleep fait, mais à la fois appel externe-win32-méthodes ... donc un gars avec un win32-fond doit répondre que!
- Je suppose que la plupart des gens utilisent un while (condition) Thread.Sleep(1000), ou encore mieux while (condition);, construire ... c'est de la conception de l'odorat et devrait être optd avec un WaitHandle de toute façon!
- 'Ce qui rend l'un thread en attente d'un énorme gaspillage' hein? Si certaines protocole spec demande une pause d'une seconde avant de continuer, ce qui se passe à attendre 1 seconde? Du fil, quelque part, va avoir à attendre! Les frais généraux pour le fil de créer/détruire est souvent hors de propos, car un thread doit être posée de toute façon, pour d'autres raisons et il fonctionne pendant la durée du processus. Je serais intéressé de voir une façon d'éviter contexte-bascule lorsqu'un spec dit "après la mise en marche de la pompe, attendez au moins dix secondes pour que la pression se stabilise avant l'ouverture de la vanne d'alimentation'.
- Droit, si un protocole spec demandes en attente, puis la filature et l'attente pourrait être la bonne chose à faire. Mais généralement, ce n'est pas le cas. C'est un hareng rouge argument.
- résumé: nous avons 2 différents cas d'utilisation: 1) nous sommes en attente parce que nous savons un laps de temps spécifique alors que nous devrions continuer (utiliser Thread.Sleep ou similaires) 2) nous sommes en attente en raison des changements de condition de quelques temps ... mot-clé(s) temps! si l'état-vérifier dans notre code de domaine, nous devrions utiliser WaitHandles - sinon le composant externe doit fournir une certaine forme de crochets ... si ce n'est pas sa conception, c'est mal! Ma réponse couvre principalement les cas d'utilisation 2 ...
- amélioré ma réponse 🙂
- il est au-delà de l'argument que sleep() peut être, et est souvent utilisé comme un temps de latence en proie à des ressources et à perdre pisse-pauvres inter-thread comms mécanisme qui peut être remplacé par des plus efficaces de signalisation. Le seul problème que j'ai est avec la conclusion que sleep() ne doit jamais être utilisé, sauf dans certains restreint de tests de rôle.
- pal, je vous aime ... de toute façon, j'ai essayé de couvrir ce dans mon edit - malheureusement, je ne peux pas (et ne veux pas) modifier la citation, car elle est fondée sur un blog-entry - édition donc ma citation serait tout à fait filaire 🙂 - c'est pas ma conclusion, c'est l'original auteurs ... j'ai inclus ma conclusion en edit, qui couvre votre prière!
- J'ai lu le post de nouveau. Je ne vois pas de poissons de toutes les couleurs dans mes commentaires. Andreas sorti du web: "Thread.Le sommeil a son utilisation: simulation des opérations de longue durée alors que les tests de débogage sur un thread MTA. Dans .NET il n'y a pas d'autre raison pour l'utiliser". Je soutiens qu'il existe de nombreuses applications où un sleep() l'appel est, bien, juste ce qui est nécessaire. Si leigons de développeurs, (car il y en a beaucoup), insistent sur l'utilisation de sleep() boucle tant que la condition des moniteurs qui doivent être remplacés par des événements/condvars/semas/whatever, c'est pas de justification à une affirmation selon laquelle "il n'y a pas d'autre raison pour l'utiliser".
- en réponse à votre edit, oui, je suis d'accord à 100%, l'utilisation de sleep() doit être évitée.
- hehe, j'ai une astuce pour "créer une discussion" chat - outre le fait que: je dirais que les applications (dans l'environnement de l'entreprise), ce qui nécessite un peu de sommeil-mécanisme, sont pour la plupart fortement dependend en temps réel de traitement et/ou matérielle directe-utilisation. Donc, soit Thread.Sleep ou C# n'est pas la meilleure façon de mettre en œuvre un tel scénario (mais peut-être le plus confortable possible 🙂 )!
- L'article que vous lien est inexact quand il dit "Il y a une non-rupture de l'utilisation de Thread.Sommeil: Thread.Sleep(0). Cela indique au système que vous voulez déclarer forfait pour le reste du thread timeslice et laissez l'autre, l'attente, le thread d'exécution.". Thread.Sleep(0) ne céder à des threads de même ou une plus grande priorité, Thread.Sleep(1) est nécessaire de céder à une quelconque thread en attente. Sur une machine mono-PROCESSEUR, c'est plus que possible que quelque chose vous appelle juste Thread.Sleep(0) dans ce qui est destiné à être un bref serré spin attendre 3secs pour le thread de priorité faible d'attente pour être stimulé.
- en fait, l'auteur développe son entrée dans un commentaire ("le samedi, novembre 14, 2009 7:56 AM par PeterRitchie"), où il met en évidence le fait qu'il n'était pas après fil-priorisation dans son article ...
- Assez juste, j'ai lu certains mais pas à tous les commentaires. Bien sûr, l'évolution des priorités des threads est plus que Thread.Sleep de a-sa-place-mais-plus-utilise-sont-une-erreur, mais si vous écrivez quelque chose qui n'est pas complètement le contrôle de tous les fils qu'il pourrait peut-être voir ensuite c'est une affaire importante à prendre en compte. Si vous avez à tourner serré (pas en soi quelque chose il faut le faire souvent) avant de l'enfiler.Sleep(0) et maintenant de nouveau et de le jeter dans l'étrange Fil.Sleep(1) si vous avez un seul noyau à utiliser.
- En 30 ans de développement d'une application multithread, (la plupart du temps C++/Delphi/Windows), je n'ai jamais vu aucun besoin de sommeil(0) ou sleep(1) boucles dans tous les livrables du code. Parfois, j'ai poussé dans ce code à des fins de débogage, mais il n'est jamais fait son chemin à la clientèle. "si vous écrivez quelque chose qui n'est pas complètement le contrôle de chaque thread' - micro-gestion des threads est une erreur aussi grave que la micro-gestion de l'équipe de développement. La gestion des threads est ce que l'OS est-il pour les outils qu'il fournit doit être utilisé.
- L'un sane cas d'utilisation je ne connais pour le Thread.Le sommeil est d'avoir un taux fixe de mise à jour en boucle, comme un jeu où vous souhaitez constante d'un FPS. Si il y a du temps à tuer avant que l'image suivante, utiliser une basse-motte Fil.Le sommeil, peut-être Thread.Sleep(1), pour donner un peu de retour pour le système.
- soins à élaborer, afin que je puisse corriger ma réponse?
- "Cela signifie que le fil est presque garanti à bloc pour plus de n millisecondes. "-- Ce n'est absolument pas le cas. La seule fois où il serait garanti à bloc pour les+ de 15 ms serait si il y avait effectivement un autre fil il y à consommer ceux 15ms. Si tous les autres threads de rendement, puis un sleep(0) ou sleep(1) POURRAIT revenir plus tôt... surtout sur un CPU avec beaucoup de cœurs. Il y a maintenant aussi des performances plus élevées thread options que vous pouvez profiter de la garantie 1ms tranches de temps si elle est utilisée correctement (pour l'audio threads et autres).
- En fait, la demande est toujours vrai ... Mais le concret de la résolution dépend fortement de l'OS (et si vous êtes un consommateur ou la version serveur) et la mise en œuvre de la patrie, de planificateur et le temps entre les changements de contexte (qui est en quelque sorte relié à la consommation vs serveur) - vous ne pouvez pas faire mieux que cette résolution ... Joe Duffy couvre cette question dans son livre "la Programmation Simultanée sur Windows" à la page 163ff "Quantums". Voir aussi stackoverflow.com/questions/2387980/thread-quantum
- href="http://forums.guru3d.com/showpost.php?s=923932e05f6d7c7a46dbb744a00a18b7&p=5144097&postcount=5" >forums.guru3d.com/... et microsoftpressstore.com/articles/... pour plus d'information sur ce sujet.
- eh bien... je viens de réaliser que j'ai cité la mauvaise ligne dans ma "citation".... mes excuses pour la confusion... je voulais dire de contester la déclaration qui doivent attendre pour l'ENSEMBLE de la timeslice avant que le thread se réveille à nouveau. Un Sleep(0) généralement de revenir immédiatement si il n'y a pas d'autres threads de prendre le temps tranches. Beaucoup dépend de l'OS, oui c'est vrai, mais même les piddly-peu de FreeRTOS que j'utilise pour les systèmes Embarqués de ne pas me faire attendre toute une timeslice quand il n'y a pas d'autres threads actifs. Si thread planificateurs exploité de la sorte... qu'ils avaient de prendre une année de démarrage.
- merci pour la clarification. Je dois être honnête w/ vous: Ma réponse couvre un Windows uniquement scénario, où il est presque impossible d'avoir la même quantité ou moins de fils que les cœurs disponibles (w/ HT) dans un botté d'exploitation et, par conséquent, le temps supplémentaire, en raison du contexte commutateurs, est plus ou moins inévitable. Enfin, j'espère que le devis initial est assez explicite, comme il l'OMI stipule clairement que le temps supplémentaire provient des changements de contexte, pas de la quantums lui-même. Si vous sentez le besoin de précisions supplémentaires, je serais heureux de s'adapter ma réponse en conséquence! Laissez-moi savoir
- de soins, d'élaborer, de sorte que je peux corriger ma réponse?
- Je downvoted vous il y a quelques années, car il est difficile de donner plus de poids à votre réponse sans un exemple autre que "ne pas faire". J'ai utiliser le Fil de discussion.Sleep(1) en continu travailleur boucles ("check pour travailler, faire un travail, de répétition"), qui peuvent ne pas avoir de travail à faire à chaque cycle. Sans elle, la totalité de cœur de processeur est utilisé à 100%.
- ressources ressuscité 🙂
InformationsquelleAutor Andreas Niedermair
32

SCÉNARIO 1 - attendre async l'achèvement de la tâche: je suis d'accord que WaitHandle/Auto|ManualResetEvent devrait être utilisé dans le scénario où un thread est en attente de tâche sur un autre thread pour terminer.

SCÉNARIO 2 - la durée de la boucle: Cependant, comme un brut mécanisme de synchronisation (alors que+Thread.Le sommeil) est parfaitement bien pour 99% des applications qui ne nécessitent PAS de savoir exactement lorsque le Thread bloqué devrait "wake up*. L'argument qu'il faut 200k cycles de la création du thread n'est pas valide - le calendrier de la boucle de fil doit être créée de toute façon et 200k cycles est juste un autre grand nombre (dites-moi combien de cycles pour ouvrir un fichier/socket/db appels?).

Alors si en+Thread.Des travaux de sommeil, pourquoi compliquer les choses? Seule la syntaxe des avocats, serait, pratique!
- Heureusement, nous avons maintenant TaskCompletionSource pour efficacement en attente d'un résultat.
InformationsquelleAutor Swab.Jat
7

J'aimerais répondre à cette question à partir d'un codage de la politique de la perspective, qui peut ou peut ne pas être utile à tout le monde. Mais surtout quand vous travaillez avec des outils qui sont destinés à 9-5 entreprise programmeurs, les gens qui écrivent de la documentation ont tendance à utiliser des mots comme "ne devrait pas" et "ne jamais" pour dire "ne fais pas cela, sauf si vous savez vraiment ce que vous faites et pourquoi".

Un couple de mes autres favoris dans le C# monde sont ce qu'ils vous disent de "ne jamais appeler de verrouillage(ce)" ou "ne jamais appeler GC.Collect()". Ces deux sont de force déclaré dans beaucoup de blogs et de documentation officielle, et de l'OMI qui sont complètes de la désinformation. À un certain niveau, cette désinformation sert son but, en ce qu'il garde les débutants loin de faire des choses qu'ils ne comprennent pas avant de l'avoir pleinement des recherches sur les alternatives, mais en même temps, il est difficile de trouver des informations via les moteurs de recherche qui semblent tous pointer vers des articles de vous dire de ne pas faire quelque chose tout en n'offrant pas de réponse à la question "pourquoi pas?"

Politiquement, il se résume à ce que les gens considèrent le "good design" ou "mauvais design". La documentation officielle ne doit pas dicter le design de mon application. Si il y a vraiment une raison technique que vous ne devriez pas appel à sleep(), puis de l'OMI, la documentation doit indiquer qu'il est totalement d'accord pour l'appeler en vertu des scénarios spécifiques, mais peut-être offrir des alternatives des solutions scénario indépendant ou plus approprié pour les autres scénarios.

Clairement appelant "sleep()" est utile dans de nombreuses situations, lorsque les délais sont clairement définis dans le monde réel-temps, toutefois, il existe des systèmes plus sophistiqués pour l'attente et de signalisation des threads qui doit être pris en compte et compris avant de commencer à jeter un sleep() dans votre code, et en jetant inutile de sommeil() relevés dans votre code est généralement considéré comme l'un des débutants tactique.

InformationsquelleAutor Jason Nelson
3

C'est le 1).la filature et 2).boucle d'interrogation de vos exemples que les gens en garde contre, pas le Fil.Sleep() de la partie.
Je pense que le Thread.Sleep() est généralement ajoutés pour améliorer facilement le code qui tourne ou dans un bureau de vote de la boucle, c'est juste associé avec les "mauvais" du code.

En plus, les gens faire des trucs comme:
```
while(inWait)Thread.Sleep(5000); 
```
où la variable inWait n'est pas accessible dans un thread-safe, ce qui provoque également des problèmes.

Ce que les programmeurs veulent voir, c'est le fils contrôlé par des Événements et de Signalisation et Verrouillage des constructions, et quand vous faites cela, vous n'aurez pas besoin de Thread.Sleep(), et les préoccupations au sujet de thread-safe variable d'accès sont également éliminées. Comme un exemple, vous pourriez créer un gestionnaire d'événement associé à la classe FileSystemWatcher et utiliser un événement pour déclencher votre 2ème exemple au lieu de boucle?

Andreas N. mentionné, lire Filetage en C#, par Joe Albahari, il est vraiment vraiment bon.
- Alors, quelle est l'alternative à faire ce qui est dans votre exemple de code?
- kuhaku - Oui, bonne question. Évidemment Fil.Sleep() est un raccourci, et parfois un gros raccourci. Pour l'exemple ci-dessus, le reste du code dans la fonction ci-dessous les bureaux de la boucle "while(inWait)Thread.Sleep(5000); " est une nouvelle fonction. Cette nouvelle fonction est un délégué (fonction de rappel) et de vous passer de tout ce qui est réglage de la "inWait" drapeau, et au lieu de changer le "inWait" drapeau, ce callback n'est appelé. Ce fut le plus court exemple que j'ai pu trouver: myelin.co.nz/notes/callbacks/cs-delegates.html
- Juste pour s'assurer que je l'ai eu, tu veux dire pour envelopper Thread.Sleep() avec une autre fonction, et l'appeler dans la boucle while?
- Non, prendre le fil de sommeil complètement.
InformationsquelleAutor mike
3

Sommeil est utilisé dans les cas où indépendant de programme(s) que vous n'avez aucun contrôle sur peut parfois utiliser couramment utilisée pour la ressource (par exemple, un fichier), que les besoins du programme d'accès lorsqu'il s'exécute, et lorsque la ressource est en cours d'utilisation par ces autres programmes de votre programme est bloqué de l'utiliser. Dans ce cas, où vous avez accès à la ressource dans votre code, vous mettez votre accès à la ressource dans un try-catch (pour intercepter l'exception lorsque vous ne pouvez pas accéder à la ressource), et vous le mettez dans une boucle while. Si la ressource est libre, le sommeil n'est jamais appelé. Mais si la ressource est bloqué, alors vous dormez pour une quantité appropriée de temps, et de la tentative d'accès à la ressource (ce pourquoi vous êtes en boucle). Cependant, gardez à l'esprit que vous devez mettre une sorte de limiteur sur la boucle, de sorte qu'il n'est pas potentiellement une boucle infinie. Vous pouvez configurer votre condition limite à N le nombre de tentatives (c'est ce que j'utilise habituellement), ou vérifier l'horloge système, d'ajouter un montant fixe de temps pour obtenir une limite de temps, et arrêter d'essayer d'accès si vous atteignez la limite de temps.

InformationsquelleAutor Steve Greene

-5

Je suis d'accord avec beaucoup ici, mais je pense aussi que ça dépend.

Récemment, j'ai fait ce code:

private void animate(FlowLayoutPanel element, int start, int end)
{
    bool asc = end > start;
    element.Show();
    while (start != end) {
        start += asc ? 1 : -1;
        element.Height = start;
        Thread.Sleep(1);
    }
    if (!asc)
    {
        element.Hide();
    }
    element.Focus();
}

C'était une simple animation de la fonction, et j'ai utilisé Thread.Sleep sur elle.

Ma conclusion, si il fait le boulot, l'utiliser.

C'est autant d'abus que DoEvents, et est indicateur d'une mauvaise conception ...

InformationsquelleAutor

-7

Pour ceux d'entre vous qui n'a pas vu un seul argument valable contre l'utilisation de Fil.Dormir dans le SCÉNARIO 2, il y a vraiment une demande de sortie de la boucle while
(SCÉNARIO 1/3 est tout simplement stupide donc pas digne de plus de mentionner)

Beaucoup de ceux qui prétendent être dans-le-savoir, en hurlant Fil.Le sommeil est le mal a omis de mentionné une seule raison valable pour ceux d'entre nous qui ont exigé une raison pratique de ne pas l'utiliser, mais c'est tout, merci à Pete - Fil.Le sommeil est Mal (peut être facilement évitée avec un timer/gestionnaire)

    static void Main(string[] args)
    {
        Thread t = new Thread(new ThreadStart(ThreadFunc));
        t.Start();

        Console.WriteLine("Hit any key to exit.");
        Console.ReadLine();

        Console.WriteLine("App exiting");
        return;
    }

    static void ThreadFunc()
    {
        int i=0;
        try
        {
            while (true)
            {
                Console.WriteLine(Thread.CurrentThread.ThreadState.ToString() + " " + i);

                Thread.Sleep(1000 * 10);
                i++;
            }
        }
        finally
        {
            Console.WriteLine("Exiting while loop");
        }
        return;
    }

-, nope, Thread.Sleep n'est pas la raison (le nouveau fil un la continue, tandis que la boucle est)! vous pouvez seulement de supprimer les Thread.Sleep-ligne - et le tour est joué: le programme ne se termine pas ainsi...

InformationsquelleAutor Swab.Jat

Vous devez vous connecter pour publier un commentaire.