De la tâche.Le rendement réel des usages?

J'ai lu à propos de Task.Yield , Et en tant que développeur Javascript, je peux dire que c'est du travail est exactement le même que setTimeout(function (){...},0); en termes de laisser les principales seul thread traiter avec d'autres trucs aka :

"ne prenez pas la puissance , de la libération de temps en temps - de sorte que d'autres pourraient
avoir un aussi..."

En js c'est en travaillant en particulier dans les grandes boucles. ( ne pas faire le navigateur gel...)

Mais j'ai vu cet exemple ici : 

public static async Task < int > FindSeriesSum(int i1)
{
    int sum = 0;
    for (int i = 0; i < i1; i++)
    {
        sum += i;
        if (i % 1000 == 0) ( after a bulk , release power to main thread)
            await Task.Yield();
    }

    return sum;
}

Comme un JS programmeur, je peux comprendre ce qu'ils ont fait ici.

MAIS en tant que programmeur C#, je me demande : pourquoi ne pas ouvrir une tâche pour elle ?

 public static async Task < int > FindSeriesSum(int i1)
    {
         //do something....
         return await MyLongCalculationTask();
         //do something
    }

Question

Avec Js je ne peux pas ouvrir une Tâche (oui je sais que je peux réellement avec des web workers) . Mais avec c# je peux.

Si oui -- pourquoi même pas la peine avec le fait de sortir de temps en temps alors que je peux le sortir à tout ?

Modifier

L'ajout de références :

De ici :
De la tâche.Le rendement réel des usages?

De ici (un autre livre électronique):

De la tâche.Le rendement réel des usages?

  • C'est un mauvais exemple, parce que Task.Yield de ne pas conserver l'INTERFACE utilisateur réactive. Aussi, async et await ne pas libérer le thread d'INTERFACE utilisateur; si vous avez un long calcul, vous aurez besoin d'utiliser Task.Run.
  • En considérant une application multithread (ASP.NET ou similaire) lorsqu'une tâche est en cours d'exécution sur le fil la piscine et le pool de threads est une ressource précieuse: Si une longue course UC tâche appel await Task.Yield() chaque seconde alors d'autres tâches en cours d'exécution devraient avoir une chance sans en attente dans la file d'attente pendant une longue période. Ne serait-ce pas un comportement juste?
  • La préemption fil de commutation intégré dans chaque système d'exploitation moderne combiné avec l'auto-réglage du pool de threads .NET de travail beaucoup mieux qu'un manuel await Task.Yield().
InformationsquelleAutor Royi Namir | 2014-05-02
  1. 55

    Quand vous voyez:

    await Task.Yield();

    vous pouvez pensez-y de cette façon:

    await Task.Factory.StartNew( 
    () => {}, 
    CancellationToken.None, 
    TaskCreationOptions.None, 
    SynchronizationContext.Current != null?
        TaskScheduler.FromCurrentSynchronizationContext(): 
        TaskScheduler.Current);

    Tout cela ne permet de s'assurer de la poursuite qui va arriver de façon asynchrone dans l'avenir. Par de manière asynchrone je veux dire que le contrôle de l'exécution sera de retour à l'appelant de la async méthode, et la poursuite rappel pas se produire sur la même trame de pile.

    Exactement quand et sur quel fil il va se passer dépend entièrement de l'appelant fil de synchronisation du contexte.

    Pour un thread d'INTERFACE utilisateur, la suite va se passer à l'avenir itération de la boucle de message, géré par Application.Run (WinForms) ou Dispatcher.Run (WPF). En interne, il s'agit du Win32 PostMessage API, qui post un message personnalisé pour le thread de l'INTERFACE utilisateur de la file d'attente de messages. Le await poursuite de callback sera appelée lorsque ce message est pompée et traitée. Vous êtes complètement hors de contrôle quand c'est exactement ce qui va se passer.

    En outre, Windows a ses propres priorités pour le pompage de messages: INFO: Fenêtre de Message Priorités. La partie la plus pertinente:

    En vertu de ce régime, l'ordre de priorité peut être considérée à trois niveaux. Tous
    les messages postés sont plus prioritaires que la saisie de l'utilisateur messages, car
    ils résident dans les différentes files d'attente. Et toutes les entrées utilisateur messages sont
    priorité plus élevée que WM_PAINT et des messages WM_TIMER.

    Donc, si vous utilisez await Task.Yield() céder à la boucle de message dans une tentative de garder l'INTERFACE utilisateur réactive, vous êtes réellement à risque d'entraver le thread de l'INTERFACE utilisateur de la boucle de message. Certains dans l'attente de la saisie de l'utilisateur messages, ainsi que WM_PAINT et WM_TIMER, ont une priorité plus basse que la publication de continuation de message. Ainsi, si vous ne await Task.Yield() sur une boucle, vous pouvez toujours bloquer l'INTERFACE utilisateur.

    C'est comment il est différent de celui du JavaScript setTimer analogie que vous avez mentionné dans la question. Un setTimer callback sera appelé après tous les utilisateurs d'entrée de message ont été traitées par le navigateur du message de la pompe.

    Donc, await Task.Yield() n'est pas bon pour faire du travail de fond sur le thread d'INTERFACE utilisateur. En fait, vous avez très rarement besoin de lancer un processus en arrière-plan sur le thread de l'INTERFACE utilisateur, mais parfois vous faites, par exemple, l'éditeur de la coloration syntaxique, orthographique, etc. Dans ce cas, utilisez le cadre de veille de l'infrastructure.

    E. g., avec WPF, vous pourriez faire await Dispatcher.Yield(DispatcherPriority.ApplicationIdle):

    async Task DoUIThreadWorkAsync(CancellationToken token)
{
    var i = 0;

    while (true)
    {
        token.ThrowIfCancellationRequested();

        await Dispatcher.Yield(DispatcherPriority.ApplicationIdle);

        //do the UI-related work item
        this.TextBlock.Text = "iteration " + i++;
    }
}

    Pour WinForms, vous pouvez utiliser Application.Idle événement:

    //await IdleYield();

public static Task IdleYield()
{
    var idleTcs = new TaskCompletionSource<bool>();
    //subscribe to Application.Idle
    EventHandler handler = null;
    handler = (s, e) =>
    {
        Application.Idle -= handler;
        idleTcs.SetResult(true);
    };
    Application.Idle += handler;
    return idleTcs.Task;
}

    Il est recommandé de que vous ne dépassez pas 50 ms pour chaque itération de cette opération en arrière-plan en cours d'exécution sur le thread d'INTERFACE utilisateur.

    Pour un non-thread d'INTERFACE utilisateur sans synchronisation contexte, await Task.Yield() passe juste à la poursuite d'un hasard de pool de threads. Il n'y a aucune garantie qu'il va être un différents thread le thread en cours, c'est seulement garanti pour être un asynchrone continuation. Si ThreadPool est affamé, il peut planifier la poursuite sur le même thread.

    Dans ASP.NET, faire await Task.Yield() n'a pas de sens, à l'exception de la solution mentionnée dans @StephenCleary réponse. Sinon, il ne feront que nuire à l'application web de la performance avec une redondance par le fil de l'interrupteur.

    Donc, est await Task.Yield() utile? OMI, pas beaucoup. Il peut être utilisé comme un raccourci pour exécuter la poursuite via SynchronizationContext.Post ou ThreadPool.QueueUserWorkItem, si vous avez vraiment besoin d'imposer l'asynchronie sur une partie de votre méthode.

    Concernant les livres que vous avez cité, à mon avis, ces approches à l'aide de Task.Yield sont mauvais. J'ai expliqué pourquoi ils ont tort pour un thread de l'INTERFACE utilisateur, ci-dessus. Pour un non-INTERFACE de pool de threads, il n'y a tout simplement pas de "d'autres tâches dans le thread à exécuter", sauf si vous exécutez une tâche personnalisée pompe comme Stephen Toub est AsyncPump.

    Mis à jour pour répondre au commentaire:

    ... comment peut-il être asynchronouse fonctionnement et de rester dans le même fil
    ?..

    Comme un simple exemple: WinForms application:

    async void Form_Load(object s, object e) 
{ 
    await Task.Yield(); 
    MessageBox.Show("Async message!");
}

    Form_Load sera de retour à l'appelant (le WinFroms code de la structure qui a tiré Load cas), et puis la boîte de message sera affiché de manière asynchrone, sur l'avenir de l'itération de la boucle de message exécuter par Application.Run(). La poursuite de callback est mis en file d'attente avec WinFormsSynchronizationContext.Post, qui, en interne, messages privés Windows message sur le thread de l'INTERFACE utilisateur de la boucle de message. Le rappel sera exécutée lorsque ce message est pompée, toujours sur le même thread.

    Dans une application console, vous pouvez exécuter un semblable sérialisation boucle avec AsyncPump mentionnés ci-dessus.

    • Noseration , bonjour 🙂 . Vous avez dit : "Il n'y a aucune garantie qu'il va être un thread différent du thread courant, c'est seulement garanti pour être asynchrone suite" . — Mais si elle doit rester sur le même thread que l'opération devenir un fonctionnement synchrone. non ? en d'autres termes , comment peut-il être asynchronouse fonctionnement et de rester dans le même fil ? asynchrounsey est sur les continuations de dire "je vais revenir et de continuer là où il s'est arrêté". mais si c'est dans le même thread , il est plus probable qu'il n'a jamais quitté la oprtaion.....non ?
    • Hey @RoyiNamir, il est tout à fait possible de continuer en mode asynchrone sur le même fil, vérifiez ma mise à jour.
    • Oui 🙂 , mais vous avez écrit le commentaire, dans le non-thread de l'INTERFACE utilisateur de la section , ce qui fait de moi la confusion.....
    • vous pouvez le faire sur un non-thread de l'INTERFACE utilisateur, avec la magie de SynchronizationContext. Avez-vous regardé AsyncPump? Après tout, asynchronisme n'est pas que le multi-threading. C'est juste quelque chose qui va se réaliser dans l'avenir. Remarque, même lorsque vous traitez avec des ThreadPool sans s.contexte, il y a une chance que la poursuite aura lieu sur le même fil (par exemple, le même pool de thread peut démarrer et servir plus tard à l'achèvement d'un async opération d'e/S, par hasard).
    • Ok merci 🙂
    • J'ai personnellement l'utilisation de la Tâche.Rendement dans un seul scénario : protégé async virtuel Tâche OverridableMethod() { attendent Tâche.Rendement(); } : ici, je veux un défaut implémentation asynchrone qui tout simplement ne rien faire, mais je ne peux pas le laisser vide, parce que la méthode doit retourner une Tâche. Peut-être il ya une meilleure façon d'atteindre cet objectif ?
    • il y a: protected virtual Task OverridableMethod() { return Task.Task.CompletedTask; }. Note async n'est pas une partie de la méthode virtuelle de la signature, de sorte que vous pouvez toujours l'utiliser lors de la substitution de cette méthode dans une classe dérivée.

    InformationsquelleAutor noseratio
  2. 17

    J'ai trouvé Task.Yield utile dans deux scénarios:

    1. Des tests unitaires pour s'assurer que le code sous test fonctionne de manière appropriée en présence d'asynchronie.
    2. Pour contourner un obscur ASP.NET d'un problème où le code d'identification de pas compléter de façon synchrone.
    InformationsquelleAutor Stephen Cleary
  3. 6

    Non, ce n'est pas exactement comme l'utilisation de setTimeout de revenir à l'INTERFACE utilisateur. En Javascript qui permettrait de toujours laisser de l'INTERFACE utilisateur mise à jour que le setTimeout a toujours un minimum de pause de quelques millisecondes, et dans l'attente de l'INTERFACE utilisateur de travailler a la priorité sur les timers, mais await Task.Yield(); ne pas le faire.

    Il n'ya aucune garantie que le rendement permettra à tout le travail sera fait dans le thread principal, au contraire, le code qui a appelé le rendement sera souvent la priorité sur l'INTERFACE utilisateur de travail.

    "Le contexte de synchronisation qui est présent sur un thread d'INTERFACE utilisateur dans la plupart de l'INTERFACE utilisateur
    les environnements vont souvent donner la priorité au travail posté pour le cadre supérieur
    que d'entrée et de rendre le travail. Pour cette raison, ne comptez pas sur les attendent
    De la tâche.Rendement(); pour garder une INTERFACE utilisateur réactive."

    Ref: MSDN: la Tâche.Méthode De Rendement

    • SI en ne s'appuyant pas sur elle - donc, pour ce que c'est-il ? pouvez-vous fournir un exemple RÉEL ?
    • Il est là pour la manipulation de multithreading, mais pas d'une manière qui est fiable pour garder l'INTERFACE utilisateur réactive. Il rend la méthode asynchrone, mais il ne le gardez pas d'être en concurrence avec le thread principal pour le CPU.
    • Si il peut gagner la principale priorité de thread , alors pourquoi voudrais-je utiliser ? Ce que vous dites, c'est que le code peut s'exécuter de synchronisation et pas async
    • Le code s'exécute asyncronously, mais vous pouvez avoir l'impression qu'il fonctionne syncronously en raison de la façon dont le travail est la priorité. Async tâches sont plus adaptés pour le travail qui est en attente que quelque chose arrive, pour le CPU intensive de travail, vous préférez regarder dans le AsParallel méthode.
    InformationsquelleAutor Guffa
  4. 2

    Tout d'abord permettez-moi de préciser: Yield n'est pas exactement la même que setTimeout(function (){...},0);. JS est exécuté dans le thread de l'environnement, de sorte que c'est la seule façon de faire d'autres activités pour se produire. Type de le multitâche coopératif. .net est exécuté dans le multitâche préemptif de l'environnement de manière explicite le multithreading.

    Maintenant de retour à Thread.Yield. Comme je l'ai dit .net vit dans préemptif monde, mais il est un peu plus compliqué que cela. C# await/async créer un intéressant mélange de ceux multitâche en mode gouverné par des machines à états. Donc, si vous omettez Yield à partir de votre code, il va simplement bloquer le thread et c'est tout. Si vous le faites régulièrement une tâche et il suffit d'appeler de démarrage (ou d'un fil), alors il va juste faire plus de choses en parallèle et, plus tard, bloquer le thread appelant lors de la tâche.Le résultat est appelé. Ce qui se passe lorsque vous ne await Task.Yield(); est plus compliqué. Logiquement, il débloque le code appelant (similaire à la JS) et l'exécution continue. Ce qu'elle ne fait - elle en prend un autre thread et poursuivre l'exécution de préemption de l'environnement avec le thread appelant. C'est donc dans le thread appelant jusqu'à la première Task.Yield et puis il est sur son propre. Les appels suivants à Task.Yield ne semblent pas faire n'importe quoi.

    Démonstration Simple:

    class MainClass
{
    //Just to reduce amont of log itmes
    static HashSet<Tuple<string, int>> cache = new HashSet<Tuple<string, int>>();
    public static void LogThread(string msg, bool clear=false) {
        if (clear)
            cache.Clear ();
        var val = Tuple.Create(msg, Thread.CurrentThread.ManagedThreadId);
        if (cache.Add (val))
            Console.WriteLine ("{0}\t:{1}", val.Item1, val.Item2);
    }

    public static async Task<int> FindSeriesSum(int i1)
    {
        LogThread ("Task enter");
        int sum = 0;
        for (int i = 0; i < i1; i++)
        {
            sum += i;
            if (i % 1000 == 0) {
                LogThread ("Before yield");
                await Task.Yield ();
                LogThread ("After yield");
            }
        }
        LogThread ("Task done");
        return sum;
    }

    public static void Main (string[] args)
    {
        LogThread ("Before task");
        var task = FindSeriesSum(1000000);
        LogThread ("While task", true);
        Console.WriteLine ("Sum = {0}", task.Result);
        LogThread ("After task");
    }
}

    Voici les résultats:

    Before task     :1
Task enter      :1
Before yield    :1
After yield     :5
Before yield    :5
While task      :1
Before yield    :5
After yield     :5
Task done       :5
Sum = 1783293664
After task      :1
    • Sortie produite sur mono 4.5 sur Mac OS X, les résultats peuvent varier sur d'autres configurations

    Si vous déplacez Task.Yield sur le dessus de la méthode, il sera par async depuis le début et de ne pas bloquer le thread appelant.

    Conclusion: Task.Yield peut rendre possible de mélanger et de synchronisation de code asynchrone. Certains, plus ou moins réalistes scénario: vous avez une forte opération de calcul et de mémoire cache locale et de la tâche CalcThing. Cette méthode vous permet de vérifier si l'article est dans le cache, si oui - article de retour, si elle n'est pas là Yield et de procéder à la calculer. Effectivement échantillon de votre livre n'est pas dénué de sens, parce que rien d'utile est atteint il. Leur remarque au sujet de GUI interactivité est tout simplement mauvais et incorrect (thread d'INTERFACE utilisateur sera verrouillé jusqu'à ce premier appel à Yield, vous ne devriez jamais le faire, MSDN est clair (et corriger) sur: "ne comptez pas sur les attendent Tâche.Rendement(); pour garder une INTERFACE utilisateur réactive".

    • L'analogie avec le JS était dans un contexte où les applications à interface graphique en c# a qu'un seul thread principal qui exécute l'INTERFACE utilisateur -- même comme JS seule boucle. ( et en JS - la solution est setTimeout(...,0 )
    • l'amour de la démo 🙂
    InformationsquelleAutor Andrey
  5. 0

    Vous êtes en supposant que la fonction longue est celle qui peut s'exécuter sur un thread d'arrière-plan. Si elle n'est pas, par exemple parce qu'il dispose d'une INTERFACE utilisateur de l'interaction, il n'existe aucun moyen pour empêcher le blocage de l'INTERFACE utilisateur tandis qu'il court, de sorte que le temps qu'il exécute doivent être conservés assez courtes pour ne pas causer des problèmes pour les utilisateurs.

    Une autre possibilité est que vous avez plus longue fonctions que vous avez threads d'arrière-plan. Dans ce scénario, il peut être mieux (ou pas, ça dépend) pour empêcher quelques-uns de ces fonctions à partir de la prise de tous vos fils.

    • Votre premier cas est potentiellement valable, mais la seconde ne l'est pas vraiment. Si vous avez plus de travail, ou même les travailleurs, que vous avez threads, puis ils vont tout simplement besoin de partager ce moment. Donner une partie de ce travail pour le thread d'INTERFACE utilisateur n'est pas utile. Si vous n'avez pas le cas, cela signifierait simplement le thread d'INTERFACE utilisateur serait au ralenti, ce qui donne que le temps de threads de travail.
    • En disant de l'INTERFACE utilisateur de l'interaction - vous parlez d'un code qui peut apparaître (Avant || Après) la await. droit ?
    • Comme une (peut-être) le même ordre d'idées: il est possible de Rejoindre des threads dans le code du serveur ... ces actions dans une Tâche signifie que n'importe qui de rejoindre ce thread n'a pas (inconsciemment) se bloquent pour l'ensemble du reste de ce Fil?
    • Si vous avez plus longue fonctions que vous avez des threads, et tous les fils sont occupé, même à court fonctions de ne pas obtenir une chance de s'exécuter, et qui peuvent donner une mauvaise expérience utilisateur, par exemple si ces fonctions d'exécution donnent à l'utilisateur une mise à jour de statut.
    • Vous avez besoin d'avoir beaucoup plus d'opérations que vous avez threads, pour que cela se produise. Il est appelé de threads. Mais dans tous les cas les plus extrêmes, le fil du planificateur est capable de résoudre le problème en changeant l'exécution sur chaque fil, permettant à chacun de tranches de temps à s'exécuter, plutôt que de l'exécution de chaque opération à la fin. Sur le dessus de que, le problème peut être résolu de manière beaucoup plus efficace grâce à l'utilisation d'un pool de threads, ce qui peut avoir exactement un nombre de travailleurs est facultative, et la file d'attente le travail à faire de façon à optimiser le débit.
    • Je pensais à des méthodes de contrôle de l'utilisation (mise à jour d'un texte de l'étiquette), qui est quelque chose qui doit se passer sur le thread d'INTERFACE utilisateur. Cette partie n'est pas quelque chose qui est un problème avec la méthode de votre question, mais c'est quelque chose qui s'applique pour le cas plus général.
    • Vous avez simplement besoin d'autant d'opérations que vous avez des threads d'arrière-plan, où aucun des tâches en cours d'exécution redonne le contrôle à tout moment raisonnable, n'est-ce pas?
    • Non, ce n'est pas quelque chose qui va causer un problème, parce que le fil est planificateurs ne sont pas que les pauvres, et la quantité de temps que le thread d'INTERFACE utilisateur aurait besoin d'être affamé pour un homme de percevoir le décalage est assez élevé. Les autres threads n'ont pas la possibilité de tenir sur le temps de calcul pour toujours; en fait, ils n'ont presque aucun contrôle sur tout la question. Il n'est pas un système coopératif, à la différence de la gestion de la thread de l'INTERFACE utilisateur à partir de dans le thread de l'INTERFACE utilisateur dans lequel quelqu'un peut intentionnellement porc le thread d'INTERFACE utilisateur pour aussi longtemps qu'ils le souhaitent, de faim tout le monde de sortir.
    • Ce n'est pas tout ce que je voulais dire. Si tous les threads d'arrière-plan sont occupés à l'exécution de longue pose, et rien, tente alors de démarrer une nouvelle tâche, que de nouvelles tâches n'obtiendrez pas une chance de s'exécuter jusqu'à ce que l'ensemble de ces tâches en cours d'exécution ont fini.
    • C'est faux. Le thread CPU scheduler fixera il pour travailler un peu avant de tous les autres threads ont fini, cela signifie simplement que chaque thread doit attendre un peu plus de temps pour sa prochaine tranche de temps supplémentaire pour chaque thread, le système crée. Vous devez créer des centaines, si pas des milliers (même si c'est la personne à charge sur le matériel du système), de fils afin de forcer l'INTERFACE utilisateur de tranches de temps pour être si peu fréquent que pour rendre l'INTERFACE de sentir qui ne répond pas à un humain.
    • Encore une fois, ce n'est pas tout ce que je voulais dire. Je ne parle pas sur le thread de l'INTERFACE utilisateur devient lent. Je parle le thread d'INTERFACE utilisateur de démarrer une nouvelle tâche, qui irait sur un thread d'arrière-plan, faire un peu de travail court, et une fois qu'il a fini de mettre à jour l'INTERFACE utilisateur. Ce court travail serait de prendre un temps très long.
    • Il sera probablement plus long, bien sûr, qu'il doit partager son temps CPU avec d'autres threads (sauf s'il parvient à terminer son exécution dans sa première tranche de temps). Ne pas attendre d'être programmée jusqu'à ce que toutes les autres tâches qui fini bien. Il va obtenir quelques tranches de temps dès le début. Car de nombreuses opérations CPU sont de courte durée, de nouvelles opérations sont généralement donné la priorité à essayer de terminer rapidement.
    • href="http://pastebin.com/AqMJhgtS" >Voici ce que je voulais dire. Un bouton commence un travail de longue haleine (attend 10 minutes, faire semblant que ça fait beaucoup de travail utile), un autre bouton permet de lancer une tâche qui devrait se terminer rapidement (attend une seconde, faire semblant qu'il est encore en train de faire un travail utile). Début assez long tâches en cours d'exécution, puis commencer un court-tâche en cours, et vous aurez toujours être laissées en attente d'un très long temps, même pour le court-tâche en cours d'exécution à la fin. L'INTERFACE utilisateur de ne pas être lent, mais si le court-tâche en cours d'exécution est censé faire un peu de travail avant de l'INTERFACE utilisateur est mise à jour, c'est encore une mauvaise expérience utilisateur.
    • Dans ce cas, vous utilisez le pool de threads, plutôt que de créer de nouveaux threads. Il y a un certain nombre de résolutions possibles ici. Vous ne devriez pas effectuer vraiment longue à exécuter des opérations dans le pool de threads (il est conçu pour les lots de taille raisonnable, des unités de travail). Bâton de la "longue course" la tâche de l'option de création de soupçon et de ne pas utiliser le pool de threads, et donc de ne pas causer ce problème. L'autre option est de casser une grosse tâche en plusieurs petites tâches. Certaines opérations sont bien adaptés pour que, certains ne le sont pas.
    • Troisième option: laisser le long d'exécution des tâches de rendement, de temps à autre. Utile si vous ne pouvez pas anticiper à l'avance si elle doit être traitée comme longues. D'où ma réponse.
    • Techniquement c'est juste une façon d'accomplir la deuxième option que j'ai mentionné, c'est juste une assez mal conçu manière de l'accomplir. Si une tâche est bien adapté à être brisée, puis de la diviser. Si ce n'est pas, il suffit de coller LongRunning sur elle plutôt que de yield tous sur la place.

    InformationsquelleAutor
  6. 0

    Je pense que personne a fourni la réponse réelle lors de l'utilisation de la Tâche.Le rendement.
    Il est surtout nécessaire si une tâche utilise une boucle sans fin (ou de longues synchrone de l'emploi), et peut potentiellement être un pool de threads thread exclusivement (pas de permettre à d'autres tâches à utiliser ce fil). Cela peut se produire si à l'intérieur de la boucle, le code s'exécute de façon synchrone. le Tâche.Rendement rééchelonne la tâche pour le pool de threads de la file d'attente et les autres tâches qui attendaient le fil peut être exécutée.

    L'exemple:

      CancellationTokenSource cts;
  void Start()
  {
        cts = new CancellationTokenSource();

        //run async operation
        var task = Task.Run(() => SomeWork(cts.Token), cts.Token);
        //wait for completion
        //after the completion handle the result/cancellation/errors
    }

    async Task<int> SomeWork(CancellationToken cancellationToken)
    {
        int result = 0;

        bool loopAgain = true;
        while (loopAgain)
        {
            //do something ... means a substantial work or a micro batch here - not processing a single byte

            loopAgain = /* check for loop end && */  cancellationToken.IsCancellationRequested;
            if (loopAgain) {
                //reschedule  the task to the threadpool and free this thread for other waiting tasks
                await Task.Yield();
            }
        }
        cancellationToken.ThrowIfCancellationRequested();
        return result;
    }

    void Cancel()
    {
        //request cancelation
        cts.Cancel();
    }
    • À partir de la deuxième pensée, vous pourriez probablement utiliser ça comme ça, mais il ne se sent pas comme un bon design: lancement d'un grand tas de CPU-limites des tâches pour le pool de threads (plus qu'elle ne peut gérer), de sorte qu'ils ont de rendement avec Task.Yield() de donner à leurs pairs une chance de s'exécuter. Il ya de meilleures options pour simultanées lié au PROCESSEUR de tels scénarios, par exemple Parallel ou TPL Dataflow.
    • La possible utilisation de ce modèle si le code de la boucle s'exécute définis par l'utilisateur gestionnaire. Le code ne sais pas comment il se comporte - si elle est asynchrone ou synchrone. Donc, par précaution, à la fin de la boucle, il est préférable d'avoir une Tâche.Le rendement. Ce qui est commun dans le message de manutention de bus. Lorsque le bus instancier des gestionnaires et de traiter les messages. Si elle a beaucoup de travailleurs qui s'exécutent en parallèle, alors il peut exaust le pool de threads les threads. Je l'ai utilisé la mise en œuvre de travailleur coordonnateur github.com/BBGONE/REBUS-TaskCoordinator
    • Et encore une chose - ce qui peut être testé. J'ai un TaskCoordinator laboratoire de test github.com/BBGONE/TaskCoordinator qui utilise ce modèle. Sans l'aide de la Tâche.Rendement si vous configurez pour exécuter un grand nombre de tâches en parallèle pour traiter les messages, alors vous ne recevrez pas les messages dans la console d'apparaître, parce que tous les pool de threads sont occupés, et le pool de threads ne pas ajouter de la plus - en raison de l'utilisation élevée de l'UC. Mais lors de l'utilisation de la Tâche.Rendement - les messages d'état s'affichent dans la console. Et il traite environ 200 000 messages par seconde, et quand il y a moins de frais généraux (pas de sérialisation) - près de 500 000 fois par seconde.
    • Je ne pense pas que l'aide de la Tâche.Taux de rendement à surmonter ThreadPool la famine, tandis que la mise en œuvre de producteur/consommateur modèle est une bonne idée. Je vous suggère de vous poser une autre question si vous voulez entrer dans les détails du pourquoi.
    • on dirait que vous êtes 🙂 stackoverflow.com/questions/53263258/...
    • Je ne sais pas pourquoi il a eu des bas-voté si, elle est toujours un exercice intéressant, en particulier si vous utilisez un personnalisé du planificateur de tâches de factoriser les ThreadPool.
    • Je sais pourquoi il est downvoted. Parce que les gens ne pas le tester - comment cela fonctionne dans le monde réel.Ils sont plus théorique que pratique. Dans le monde réel, il ya généralement un plus grand nombre de tâches de traitement que le nombre de processeurs sur le comp. Vous avez 2 options - utilisation de pool de threads.QueueUserWorkItem directement, ou utiliser une boucle avec async vous attendent. Async Attendent la même chose, il les files d'attente des éléments à la piscine. Si le travail effectué à chaque itération est plus ou moins importante, puis un supplément asynchrone attendent ne fait pas de mal. Mais il augmente la réactivité du système.
    • voir mon commentaire there. Ce serait formidable si vous pouvez soutenir votre vision avec un test de référence dans le genre, et puis nous pourrions tous apprendre quelque chose de nouveau. Si vous le prenez sur ce, n'hésitez pas à répondre à votre propre question. Gardez à l'esprit que, même si la valeur par défaut ThreadPool victoires, dans la vraie vie, vous ne pouvez simplement pas monopoliser tous ses threads pour microtasks comme ceux, parce que c'est une ressource partagée utilisée par le runtime ailleurs.

    InformationsquelleAutor Maxim T