Quelle est la différence entre la Tâche.Start/Wait et Async/Await?

J'ai peut-être raté quelque chose mais quelle est la différence entre faire:

public void MyMethod()
{
  Task t = Task.Factory.StartNew(DoSomethingThatTakesTime);
  t.Wait();
  UpdateLabelToSayItsComplete();
}

public async void MyMethod()
{
  var result = Task.Factory.StartNew(DoSomethingThatTakesTime);
  await result;
  UpdateLabelToSayItsComplete();
}

private void DoSomethingThatTakesTime()
{
  Thread.Sleep(10000);
}

InformationsquelleAutor Jon | 2012-03-01

.net-4.5 async-await c#conceptual task-parallel-library

383

J'ai peut-être raté quelque chose

Vous.

quelle est la différence entre faire Task.Wait et await task?

Vous commandez votre repas à partir du serveur au restaurant. Un moment après votre commande, un ami arrive et s'assoit à côté de vous et commence une conversation. Maintenant, vous avez deux choix. Vous pouvez ignorer votre ami jusqu'à ce que la tâche est terminée: vous pouvez attendre jusqu'à ce que votre soupe arrive et ne rien faire d'autre pendant que vous attendez. Ou vous pouvez répondre à votre ami, et lorsque votre ami arrête de parler, le serveur vous apportera votre soupe.

Task.Wait blocs jusqu'à ce que la tâche est terminée -- vous ignorez votre ami jusqu'à ce que la tâche est terminée. await conserve traitement des messages dans la file d'attente de messages, et lorsque la tâche est terminée, il place en file d'attente un message qui dit "reprendre là où vous l'avez laissé après qui l'attendent". Vous parlez à votre ami, et quand il y a une pause dans la conversation, la soupe arrive.
- N'est-ce pas Task.Wait une coopérative de bloc? c'est à dire qu'il ne va pas bloquer le thread il suffit de choisir une autre tâche de la piscine et de l'exécuter que si le délai d'attente est toujours actif.
- Non, il n'est pas. Comment aimez-vous que l'attente pour un Task qui prend 10 ms aurait fait exécuter une 10 de l'heure Task sur votre fil, ainsi le blocage de vous pour l'ensemble de 10 heures?
- Lippert .. donc ici est ma principale préoccupation. attendent conserve traitement des messages dans la file d'attente de messages et lorsque la tâche est terminée .... donc, signifie-t-il attendre crée un autre fil et les délégués de tâche et dans la moyenne des temps de garde sur le traitement des messages dans la file d'attente de message? Mais beaucoup de dit "en attente de ne pas créer un nouveau fil de discussion" ? Alors, qui exécute la tâche ?
- Le attendre opérateur n'est pas ne rien à l'exception de évaluer son opérande, puis retourner immédiatement une tâche pour le courant de l'appelant. Les gens reçoivent cette idée dans leur tête que l'asynchronie ne peut être atteint que par le biais de déchargement de travail sur les threads, mais c'est faux. Vous pouvez faire cuire le petit déjeuner et de lire le livre alors que le pain dans le grille-pain sans l'embauche d'un cuisinier pour regarder le grille-pain. Les gens disent qu'il doit y avoir un fil-un travailleur -- cachés à l'intérieur du grille-pain, mais je vous assure que si vous regardez dans votre grille-pain, il n'y a pas de petit gars là, à regarder le toast.
- Alors, qui est en train de faire le travail que vous demandez? Peut-être un autre thread est en train de faire le travail, et que le thread a été affecté à une unité centrale, de sorte que le travail est fait. Peut-être le travail qui est fait par le matériel et il n'y a pas de fil à tous. Mais sûrement, dites-vous, il doit être fil dans le matériel. Pas de. Matériel existe au-dessous du niveau de threads. Il n'est pas besoin de fil! Vous pouvez bénéficier de la lecture de Stephen Cleary l'article Il n'y a Pas de Fil.
- Maintenant, la question, supposons qu'il y est asynchrone travail accompli et il n'y a pas de matériel, et il n'y a aucun autre thread. Comment est-ce possible? Eh bien, supposons que la chose que vous avez attendu les files d'attente en place une série de messages de windows, dont chacun fait un petit peu de travail? Maintenant ce qui se passe? Vous revenez de contrôle de la boucle de message, il commence à retirer les messages de la file d'attente, faire un peu de travail à chaque fois, et le dernier travail qui est fait est "exécuter la continuation de la tâche". Aucun fil supplémentaire!
- Maintenant, pensez à ce que je viens de dire. Vous savez déjà que c'est comment Windows fonctionne. Vous exécutez une série de mouvements de la souris et les clics de boutons et autres joyeusetés. Les Messages sont mis en file d'attente, transformé à son tour, chaque message provoque une infime quantité de travail à faire, et quand c'est fait, le système continue à aller. Asynchrone sur un thread n'est rien de plus que ce que vous êtes déjà utilisé pour: répartir les tâches importantes en petits bouts, en file, et l'exécution de tous les morceaux dans l'ordre. Certaines de ces exécutions cause autres travail à la file d'attente, et la vie continue. Un fil!
- Alors quel est le point de la Tâche.Attends, si il bloque? Pourquoi envelopper le code dans une Tâche?
- Vous devriez ne jamais les utiliser Task.Wait. Vous auriez à n'utiliser que si vous devez absolument le bloc jusqu'à ce que la tâche est terminée, et vous savez qu'il ne va pas à l'impasse si vous le faites.
- est-ce différent lorsque vous l'utilisez avec de la Tâche.Courir et Attendre? parce que msdn dit qu'il est asynchrone msdn.microsoft.com/en-us/library/hh195051(v=vs. 110).aspx
- Est-ce différent de ce à quoi? Si vous voulez l'asynchronie alors pourquoi sur terre serait vous faire synchrone attendre?
- Dans la MSDN exemple, à l'aide de la Tâche.Course pour exécuter l'Action spécifiée dans un nouveau thread, il est asynchrone. Vous vous retrouvez avec 2 fils: thread principal et l'arrière-plan/thread de tâche. La différence avec la Tâche.Attendez vs attendent c'est que les Tâches.Attente en bloc sur le thread principal jusqu'à ce que le thread d'arrière-plan des finitions, où vous attendent permettrait le thread principal pour poursuivre l'exécution d'autres choses. Dans la MSDN exemple, la méthode main doit attendre pour la tâche à effectuer, ou bien il serait juste de retour et le programme prendrait fin avant que la tâche ne pourrait terminer.
- La clé dans votre réponse (pour moi) était: La soupe arrive lorsque votre ami s'arrête parler. Mais je suis encore confus à propos d'une chose: à l'Aide de async et await libère des ressources (sur le thread en cours) pour exécuter du code dans la méthode x alors que la méthode y (l'attendu) est toujours occupé. Que, fondamentalement, accélère l'exécution de x. Mais que faire si je veux y pour courir plus vite? En d'autres termes, si j' ne voulez pas attendre le résultat, mais continuer tout droit. C'est que là où j'ai besoin de frayer les threads?
- Ne pensez pas accélérer le traitement d'une tâche. Pensez-y comme garder un travailleur à la fois occupé et réactive. Les tâches de courir aussi vite qu'ils courent; l'asynchronie est à propos de l'utilisation efficace des travailleurs. Vous ne voulez embaucher plus de travailleurs, si vous avez un travail qui peut être divisé entre eux facilement. Si il faut 20 minutes pour cuire une tarte, l'embauche de 20 cuisiniers n'est pas de la tarte, en une minute.
- Si ce que vous souhaitez exprimer est "je n'ai pas de soins quand cette tâche est terminée; gardez l'exécution de ce flux de travail", puis sur il suffit de ne pas attendre. Le sens de l'attendent est c'est une position où ce flux de travail ne peut pas continuer jusqu'à ce que cette tâche est terminée. Si vous pensez que vous attendent signifie "faire de cette asynchrone", alors vous devez arrêter de penser que aujourd'hui. Attendent signifie "trouver quelque chose d'autre à faire si ce déjà-travail asynchrone n'est pas terminée".
- En bref: attendre est le séquençage de l'opération asynchrone, les flux de travail; il dit ce qui doit arriver avant quoi d'autre doit se faire. Si ce n'est pas clair, cette question peut aider: stackoverflow.com/questions/47603675/...
- Pour ceux qui, comme moi, ne peuvent pas être entièrement à l'aise sans au moins une explication de base de l'endroit où, à un mécanisme de niveau, le code suivant est à venir à partir de: Threads ont une SynchronizationContext. Par exemple, WindowsFormsSynchronizationContext exécute les messages dans la boucle de message un par un. En attente sur le thread d'INTERFACE utilisateur signifie simplement sauter au message suivant dans la boucle de message.
- Si vous regardez dans votre tête pendant que vous lisez le journal, n'est-ce pas là un petit gars là, à écouter pour le toast popping up?
- C'est le message qui indique que la tâche est terminée.
- J'ai lu à plusieurs endroits que async-await ne peut que l'aider si l'opération est IO base; pas le processeur de la faim. Pourquoi donc? Si je lance en mode synchrone, mon programme tout au long de l'exécution utilise 10% de CPU. Si je casse mon programme en 2 petits morceaux et exécuter les morceaux de manière asynchrone, il faut terminer l'exécution de la mi-temps avec 20% d'utilisation du PROCESSEUR. Veuillez expliquer si je suis encore miss-comprendre quelque chose.
- async-attendent peut certainement aider avec CPU-lourds opérations, de deux manières. Tout d'abord, il peut aider dans la façon dont vous décrivez. Utiliser le TPL pour diviser le travail en autant de parties qu'il y a des CPUs, exécuter le travail en parallèle, et d'attendre les résultats. Si le travail est hautement parallélisables et plus cher que d'attribuer un thread, c'est une victoire. Deuxièmement, vous pouvez garder tous vos travaux sur le thread de l'INTERFACE utilisateur, mais de mettre en tâche de rendements toutes les 10 millisecondes environ. Votre travail sera plus long, mais le fil sera adapté à la saisie de l'utilisateur plutôt que d'accrocher l'INTERFACE utilisateur.
- La chose importante à retenir est que async attendent est à propos de la coordination de flux de travail qui contiennent des opérations à latence élevée. Il n'est pas question de savoir si la source de latence est IO ou CPU; c'est la tâche du fournisseur à s'inquiéter.
InformationsquelleAutor Eric Lippert
116

À démontrer Eric réponse est ici un peu de code:
```
public void ButtonClick(object sender, EventArgs e)
{
  Task t = new Task.Factory.StartNew(DoSomethingThatTakesTime);
  t.Wait();  
  //If you press Button2 now you won't see anything in the console 
  //until this task is complete and then the label will be updated!
  UpdateLabelToSayItsComplete();
}

public async void ButtonClick(object sender, EventArgs e)
{
  var result = Task.Factory.StartNew(DoSomethingThatTakesTime);
  await result;
  //If you press Button2 now you will see stuff in the console and 
  //when the long method returns it will update the label!
  UpdateLabelToSayItsComplete();
}

public void Button_2_Click(object sender, EventArgs e)
{
  Console.WriteLine("Button 2 Clicked");
}

private void DoSomethingThatTakesTime()
{
  Thread.Sleep(10000);
}
```
- +1 pour le code (il est préférable de l'exécuter une fois, lu des centaines de fois). Mais l'expression "//If you press Button2 now you won't see anything in the console until this task is complete and then the label will be updated!" est trompeur. En appuyant sur le bouton avec t.Wait(); dans l'événement clic du bouton gestionnaire de ButtonClick() il n'est pas possible d'appuyer sur quoi que ce soit et puis voir quelque chose dans la console et mise à jour de l'étiquette "jusqu'à ce que cette tâche est terminée" depuis l'interface graphique est bloqué et ne répond pas, c'est tous les clics ou les interactions avec les GUI sont PERDU jusqu'à l'achèvement de la tâche en attente
- Je suppose que Eric suppose que vous avez une compréhension de base de l'api de Tâches. Je regarde le code et me dire "ouais t.Wait va bloquer le thread principal jusqu'à ce que la tâche est terminée."
InformationsquelleAutor Jon

Cet exemple illustre la différence très clairement. Avec async/await le thread appelant ne va pas bloquer et de poursuivre l'exécution.

static void Main(string[] args)
{
    WriteOutput("Program Begin");
    //DoAsTask();
    DoAsAsync();
    WriteOutput("Program End");
    Console.ReadLine();
}

static void DoAsTask()
{
    WriteOutput("1 - Starting");
    var t = Task.Factory.StartNew<int>(DoSomethingThatTakesTime);
    WriteOutput("2 - Task started");
    t.Wait();
    WriteOutput("3 - Task completed with result: " + t.Result);
}

static async Task DoAsAsync()
{
    WriteOutput("1 - Starting");
    var t = Task.Factory.StartNew<int>(DoSomethingThatTakesTime);
    WriteOutput("2 - Task started");
    var result = await t;
    WriteOutput("3 - Task completed with result: " + result);
}

static int DoSomethingThatTakesTime()
{
    WriteOutput("A - Started something");
    Thread.Sleep(1000);
    WriteOutput("B - Completed something");
    return 123;
}

static void WriteOutput(string message)
{
    Console.WriteLine("[{0}] {1}", Thread.CurrentThread.ManagedThreadId, message);
}

DoAsTask De Sortie:

[1] Programme De Commencer 
[1] 1 - Départ 
[1] 2 - Tâche a commencé 
[3] A - a Commencé quelque chose 
[3] B - Terminé quelque chose 
[1] 3 - la Tâche est terminée avec un résultat: 123 
[1] De La Fin Du Programme

DoAsAsync De Sortie:

[1] Programme De Commencer 
[1] 1 - Départ 
[1] 2 - Tâche a commencé 
[3] A - a Commencé quelque chose 
[1] De La Fin Du Programme 
[3] B - Terminé quelque chose 
[3] 3 - la Tâche est terminée avec un résultat: 123

Mise à jour: Amélioration de l'exemple en montrant l'ID de thread dans la sortie.

Mais si je fais :nouvelle Tâche(DoAsTask).Start(); au lieu de DoAsAsync(); j'obtiens le même functionalety, alors, où est l'avantage de l'attendent..
Avec votre proposition, le résultat de la tâche doit être évalué ailleurs, peut-être une autre méthode ou un lambda. L'async-attendent est fait le code asynchrone plus facile à suivre. C'est juste une syntaxe enhancer.
je ne comprends pas pourquoi la Fin du Programme est après - Commencé quelque chose. De ma compréhension quand il s'agit de mot clé await processus devrait s'en va immédiatement à contexte principal, puis revenir en arrière.
De ma compréhension de la Tâche.Usine.StartNew va lancer un nouveau thread à exécuter DoSomethingThatTakesTime. Comme il n'y a aucune garantie que la Fin du Programme ou de l'Un - a Commencé à être exécutés en premier.
J'ai mis à jour l'échantillon pour afficher l'Id de thread. Comme vous pouvez le voir, "Fin de Programme" et "A Commencé quelque chose" sont en cours d'exécution sur les différents threads. Donc, en fait, l'ordre n'est pas déterministe.

InformationsquelleAutor Mas

9

Wait(), va entraîner à exécuter potentiellement async code de la synchronisation de la manière. attendent le seront pas.

Par exemple, vous avez une asp.net application web. UserA appels /getUser/1 point de terminaison. asp.net application de la piscine va chercher un thread du pool de thread (Thread1) et, ce thread va faire un appel http. Si vous n'Wait(), ce fil sera bloqué jusqu'à ce http appel résout. Alors qu'il est en attente, si UserB appels /getUser/2, alors, app piscine aurez besoin pour servir un autre thread (Thread2) de faire appel http de nouveau. Vous venez de créer (Bien, extraite de l'application de la piscine, en fait) un autre thread pour aucune raison, parce que vous ne pouvez pas utiliser Thread1 il a été bloqué par Wait().

Si vous utilisez attendent sur Thread1, puis, SyncContext va gérer la synchronisation entre Thread1 et http appel. Simplement, il devra en aviser une fois que http appel est fait. En attendant, si UserB appels /getUser/2, alors, vous allez utiliser Thread1 de nouveau à faire appel http, parce qu'il a été libéré une fois qu'attendent a été touché. Puis une autre demande peut l'utiliser, même plus encore. Une fois http appel est fait (user1 ou user2), Thread1 pouvez obtenir le résultat et le retour à l'appelant (client). Thread1 a été utilisé pour plusieurs tâches.

InformationsquelleAutor Teoman shipahi
8

Dans cet exemple, pas beaucoup, pratiquement. Si vous êtes en attente d'une Tâche qui renvoie sur un autre thread (comme un WCF appel) ou la cessation de contrôle au système d'exploitation (comme les e /s de Fichier), vous attendent utilisera moins de ressources système pas de blocage à un fil.

InformationsquelleAutor foson

Dans l'exemple ci-dessus, vous pouvez utiliser "TaskCreationOptions.HideScheduler", et grandement modifier l' "DoAsTask" la méthode. La méthode elle-même n'est pas asynchrone, comme il arrive avec "DoAsAsync" parce qu'il renvoie à une "Tâche" de la valeur et est marqué comme "async", faisant plusieurs combinaisons, c'est la façon dont il me donne exactement le même que l'utilisation de "async /await":

static Task DoAsTask()
{
    WriteOutput("1 - Starting");
    var t = Task.Factory.StartNew<int>(DoSomethingThatTakesTime, TaskCreationOptions.HideScheduler); //<-- HideScheduler do the magic

    TaskCompletionSource<int> tsc = new TaskCompletionSource<int>();
    t.ContinueWith(tsk => tsc.TrySetResult(tsk.Result)); //<-- Set the result to the created Task

    WriteOutput("2 - Task started");

    tsc.Task.ContinueWith(tsk => WriteOutput("3 - Task completed with result: " + tsk.Result)); //<-- Complete the Task
    return tsc.Task;
}

InformationsquelleAutor user8545699

Vous devez vous connecter pour publier un commentaire.