Faire un choix entre ManualResetEvent ou Thread.Sleep()

Je ne suis pas sûr que la stratégie à adopter...je me concentre sur mon opération se terminé, mais j'aimerais aussi garder les problèmes de performance sur un min trop...il y a une méthode appelée Execute() qui doit attendre (exécuter de manière synchrone) jusqu'à ce qu'une opération est terminée. Cette opération se déroule sur un autre thread. Il y a 2 façons de mettre en œuvre la même chose...

En utilisant ManualResetEvent

void Execute()
{
    taskHandle = new ManualResetEvent(false);
    .
    .
    //delegate task to another thread
    .
    .
    taskHandle.WaitOne();
}

OU

À l'aide d'un simple tout en construire

void Execute()
{
    .
    .
    //delegate task to another thread
    .
    .
    while (!JobCompleted)
        Thread.Sleep(1000);
}

Laquelle des deux approches dois-je adopter...pourquoi?

EDIT:

T2. Que faire si j'ai juste eu un vide tandis que contruct? Quel est la différence...?

while(!JobCompleted);

EDIT: (quelque chose que j'ai recueillies avant)

http://www.yoda.arachsys.com/csharp/threads/waithandles.shtml - Cet article dit manualresets rapport comparativement plus lent parce qu'ils sortent de code managé et de retour dans...

Je veux juste faire remarquer Fil.Sleep(0) utilisation. Indiquez zéro (0) pour indiquer que ce fil devrait être suspendu pour permettre à d'autres threads en attente d'exécution. Dans ce cas, le Sommeil(0) vaut mieux que le Sommeil(1000), mais en utilisant WaitHandle est encore plus approprié.
Le vide tandis que la boucle est fondamentalement un spinwait - il sera tout à fait consommer du CPU. Pas recommandé.

OriginalL'auteur deostroll | 2009-11-04

  1. 13

    Par curiosité, pourquoi ManualResetEvent et pas AutoResetEvent? De toute façon, aller avec l'OS primitif sur le sommeil-le sommeil de l'approche.

    Vous pouvez également utiliser un Monitor de verrouillage (soit explicitement, par le biais de Monitor.Enter et Monitor.Exit, ou par l'intermédiaire d'un lock bloc), mais l'approche doit être basée sur ce que vous êtes en train de faire; si c'est un scénario de "il n'y a qu'un seul de ces choses et j'ai besoin d'un accès exclusif", puis utiliser un Monitor de verrouillage. Si c'est "j'ai besoin d'attendre jusqu'à ce que l'autre thread termine pour des raisons autres que l'accès aux ressources", puis utiliser une AutoResetEvent ou ManualResetEvent.

    Les suggestions pour utiliser Thread.Join sont bonnes si (et seulement si)

    1. Vous avez accès à d'autres Thread objet
    2. Vous ne voulez pas exécuter jusqu'à ce que le autre thread se termine.

    Si ce n'est pas vrai (vous n'avez pas l'accès ou l'autre thread ne sera pas arrêter, il faudra juste le signal d'un "all clear") puis Thread.Join n'est pas viable.

    La pire option est

    while(!JobCompleted);

    Que de relier le processeur avec inutile de contrôles de la variable, sans aucune pause entre eux. Oui, il va bloquer votre thread jusqu'à ce que l'opération est terminée, mais vous aurez un maximum d'utilisation de l'UC (ou au moins d'un seul noyau vaut la peine).

    lire somewher tht manuel réinitialise travail en mode noyau...si oui, alors il devrait y avoir une surcharge de performance, non? PS: j'ai édité de nouveau la question...
    Vous suggère d'aller avec l'OS primitif, mais vous devriez vraiment expliquer pourquoi.

    OriginalL'auteur Adam Robinson

  2. 4

    L'événement permet une utilisation plus efficace des processeurs - vous n'êtes pas avoir à réveiller le parent fil jusqu'à un sondage. Le noyau va vous réveiller lorsque l'événement se déclenche.

    Mais arent' manualResetevents cher par rapport aux autres de construire. J'utilise .net 2.0. Lu quelque part tht manuel réinitialise travail en mode noyau, où, comme son moniteur alternatives de travail en mode utilisateur...donc une charge supplémentaire en raison du changement de mode...! Est-ce vrai?
    Ils sont plus coûteux à créer que les Surveille, mais ils sont aussi plus complet. Il dépend de la fréquence à laquelle vous êtes en train de créer. Si vous êtes à la recherche d'exécuter des milliers de ces un deuxième, un léger approche serait mieux.

    OriginalL'auteur nitzmahone

  3. 2

    Si vous avez accès à la Thread d'origine de l'objet, ou de pouvoir l'obtenir que l'accès, vous êtes mieux de l'aide Thread.Join().

    Edit: Aussi, si ce n'est de prendre place dans une interface graphique, comme WinForms ou WPF, vous pouvez envisager d'utiliser BackgroundWorker

    je n'ai pas hve l'accès à l'objet thread...
    Ensuite, utilisez ManualResetEvent @nitzmahone suggère. Ou trouver une façon d'obtenir ce Thread. Le seul inconvénient avec l'aide de ManualResetEvent est que l'appelant et le travailleur de l'utiliser, de la création d'un éventuellement indésirables de la dépendance.
    Ne serait pas à la fois des méthodes de partage de ressources pour être en mesure de signaler les uns des autres? Dans le cas de la boucle while les deux fils doivent savoir à propos de la "JobCompleted' booléen.
    excellent point de

    OriginalL'auteur Randolpho

  4. 2

    Le principal inconvénient de l'utilisation des Thread.Sleep(), c'est que vous êtes la prise de décision sur combien de temps d'attente du thread. Le fonctionnement vous êtes en attente pour peut prendre plus ou moins temps, et en général, il est très difficile de quantifier précisément l'époque. Si le thread est en veille trop longtemps, alors vous n'êtes pas en faisant le meilleur usage des ressources du système.

    Afin d'être optimale, vous devez utiliser ManualResetEvent (ou AutoResetEvent), de sorte que votre fil est reprise dès que l'opération dépendant de finitions.

    OriginalL'auteur Steve Guidi

  5. 1

    ManualResetEvent est certainement le chemin à parcourir.

    À partir de l'extrait de code que vous avez fourni, on dirait que vous êtes de déléguer l'exécution à l'intérieur de votre méthode Execute. Si c'est le cas et que vous êtes seulement de déléguer une tâche unique, pourquoi êtes-vous de déléguer à un autre thread à tous si vous avez à attendre pour la réponse? Vous pouvez ainsi exécuter le processus de façon synchrone.

    OriginalL'auteur Mike

  6. 1

    manualresets rapport comparativement plus lent parce qu'ils sortent de code managé et à l'arrière..

    Ils sont probablement plus lent que dire d'un Attendre d'Impulsion/combo, vous devez utiliser ici, à mon avis. Mais Manual/AutoResetEvents sera beaucoup plus rapide que n'importe quel Thread.Sleep(x) que vous faites, même si vous choisissez de x = 1. Et même si vous réduisez l'horloge de Windows la résolution de 1ms.

    Que faire si j'ai juste eu un vide tandis que contruct? Quel est la différence...?

    Puis un noyau de spin à 100% jusqu'à ce que la condition tourne vrai, le vol de temps loin de d'autres sujets qui peuvent l'utiliser pour faire quelque chose d'utile, comme le calcul des images pour "Angry Birds" - ou le cpu pourrait tout simplement se rafraîchir un peu, le fait de retarder les terribles effets du réchauffement climatique pour quelques nanosecondes.

    OriginalL'auteur Eugene Beresovsky

  7. 0

    Les deux approches de faire la même chose en fait. La boucle while est un peu plus explicite, cependant, puisque vous pouvez spécifier le temps de dormir. Bien que je voudrais utiliser le XXXResetEvent classes qui sont destinées à être utilisées dans le scénario de votre travail. Je suppose que le filetage des classes serait mis en œuvre maintenant ou plus tard, avec le plus robuste le filetage du code pour gérer peut-être l'affinité des threads sur les processeurs multi.

    Un ManualResetEvent se comporte tout à fait différemment que périodiquement des bureaux de vote.

    OriginalL'auteur rocka