Async/await tâches et WaitHandle

Dire que j'ai 10N articles(j'ai besoin de les récupérer via le protocole http), dans le code de N Tâches sont lancés pour obtenir les données, chaque tâche prend 10 éléments dans la séquence. J'ai mis les éléments dans un ConcurrentQueue<Item>. Après cela, les éléments sont traités dans un thread méthode dangereuse, un par un.

async Task<Item> GetItemAsync()
{
    //fetch one item from the internet
}

async Task DoWork()
{
    var tasks = new List<Task>();
    var items = new ConcurrentQueue<Item>();
    var handles = new List<ManualResetEvent>();

    for i 1 -> N
    {
        var handle = new ManualResetEvent(false);
        handles.Add(handle);

        tasks.Add(Task.Factory.StartNew(async delegate
        {
            for j 1 -> 10
            {
                var item = await GetItemAsync();
                items.Enqueue(item);
            }
            handle.Set();
        });
    }

    //begin to process the items when any handle is set
    WaitHandle.WaitAny(handles);

    while(true)
    {
         if (all handles are set && items collection is empty) //***
           break; 
         //in another word: all tasks are really completed

         while(items.TryDequeue(out item))          
         {
              AThreadUnsafeMethod(item);    //process items one by one
         }
    }
}

Je ne sais pas ce que si la condition peut être placé dans la déclaration marqué ***. Je ne peux pas utiliser Task.IsCompleted bien ici, parce que je utiliser await dans la tâche, de sorte que la tâche est terminée très bientôt. Et un bool[] qui indique si la tâche est exécutée à la fin à l'air vraiment très laid, parce que je pense que ManualResetEvent peut faire le même travail. Quelqu'un peut-il me donner une suggestion?

OriginalL'auteur Cheng Chen | 2012-08-24

  1. 3

    Bien, vous pourrait construire vous-même, mais je pense que c'est plus facile de tonnes avec TPL Dataflow.

    Quelque chose comme:

    static async Task DoWork()
{
  //By default, ActionBlock uses MaxDegreeOfParallelism == 1,
  // so AThreadUnsafeMethod is not called in parallel.
  var block = new ActionBlock<Item>(AThreadUnsafeMethod);

  //Start off N tasks, each asynchronously acquiring 10 items.
  //Each item is sent to the block as it is received.
  var tasks = Enumerable.Range(0, N).Select(Task.Run(
      async () =>
      {
        for (int i = 0; i != 10; ++i)
          block.Post(await GetItemAsync());
      })).ToArray();

  //Complete the block when all tasks have completed.
  Task.WhenAll(tasks).ContinueWith(_ => { block.Complete(); });

  //Wait for the block to complete.
  await block.Completion;
}

    OriginalL'auteur Stephen Cleary

  2. 1

    Vous pouvez faire un WaitOne avec un délai d'attente de zéro pour en vérifier l'état. Quelque chose comme ceci devrait fonctionner:

    if (handles.All(handle => handle.WaitOne(TimeSpan.Zero)) && !items.Any())
    break;

    http://msdn.microsoft.com/en-us/library/cc190477.aspx

    "Bloque le thread courant jusqu'à ce que l'instance reçoit un signal" donc, vous avez 10 le blocage des threads en attente du signal.
    Si le délai est égal à zéro, la méthode ne prend pas en bloc. Il teste l'état de la le d'attente de la poignée et retourne immédiatement."
    ok, c'est une info que j'ai manqué. Merci, maintenant c'est ma solution préférée pour la vérification de WaitHandles.

    OriginalL'auteur BAF

  3. 0

    Merci à tous. Enfin j'ai trouvé CountDownEvent est très adapté à ce scénario. La mise en œuvre générale ressemble à ceci:(pour d'autres informations)

    for i 1 -> N
{
    //start N tasks
    //invoke CountDownEvent.Signal() at the end of each task
}

//see if CountDownEvent.IsSet here

    OriginalL'auteur Cheng Chen