Utilisation de GCD pour attendre une condition

Question

J'essaie d'imposer un ordre spécifique pour les tâches à effectuer à l'aide de Grand Central Dispatch, mais j'ai de la difficulté à comprendre la bonne façon de procéder. J'ai essayé d'utiliser des groupes de la manière suivante:

Initialisation:

startup = dispatch_group_create(); 

tâches qui doivent attendre:

//Don't want to wait on the main thread, so dispatch async to a concurrent queue 
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0L),^{ 
     //Wait until we're finished starting up 
     dispatch_group_wait(startup,DISPATCH_TIME_FOREVER); 
     //Now we can do this stuff back on the main queue 
     dispatch_async(dispatch_get_main_queue(),^{ 
      //Do work 
     }); 
    }); 

travail que je dois attendre:

dispatch_group_async(startup,dispatch_get_main_queue(),^{ // work }); 

En raison de la nature de mon application, les tâches qui doivent attendre peuvent se produire AVANT le travail que je dois attendre. Ce que je veux vraiment, c'est la capacité d'attendre une condition de cette façon quand la condition est faite, c'est fait, et tous les futurs threads peuvent faire leur chose. Est-ce que GCD a ceci?

Answer 1

Fonctionne si j'utilise un sémaphore, puis signale après chaque appel à attendre. Fonctionne également si j'appelle dispatch_group_enter et dispatch_group_leave.

Answer 2

Je ne suis pas sûr de tous les détails de votre implémentation, alors pardonnez-moi si je répète ce que vous savez déjà.

1. Créer un groupe d'expédition
2. Utilisez dispatch_group_async à une file d'attente de série. En utilisant la file d'attente série, vous êtes assuré que vos tâches sont traitées dans l'ordre que vous souhaitez. Utilisez une file d'attente concurrente si vous n'avez pas d'importance sur l'ordre, mais votre question indique qu'ils doivent être terminés dans un ordre spécifique.

3. Une fois que vous avez terminé l'envoi de toutes vos tâches, utilisez dispatch_group_notify. Cela va exécuter un bloc dans la file d'attente que vous spécifiez une fois que toutes les tâches assignées au groupe auront fini le traitement.

   dispatch_group_notify(startup, dispatch_get_main_queue(), ^{ 
        // Don't forget to release the dispatch group! 
        dispatch_release(startup) 
       // perform work block; 
   }); 
   

Pour une activité d'analyse syntaxique particulière, je dois faire un certain traitement de données qui peut être fait alors que le reste de l'activité d'analyse est en cours. J'assigne le traitement à un groupe sur une file d'attente concurrente. Puis, quand mon analyse est terminée, je vérifie pour voir si le groupe est fait. Si c'est fait, je nettoie les choses. Sinon, utilisez dispatch_group_notify() et exécutez le travail par la suite. Quelque chose de ce genre:

double delayInSeconds = 2.0; 
dispatch_time_t groupWaitTime = dispatch_time(DISPATCH_TIME_NOW, delayInSeconds * NSEC_PER_SEC); 
if (dispatch_group_wait(myDispatchGroup, groupWaitTime)==0){ 
    NSLog(@"dispatch group completed in time"); 
    dispatch_release(myDispatchGroup); 
    [self parsingCompleteWithActivity:activity]; 
}else{ 
    NSLog(@"dispatch group did not complete in time"); 
    dispatch_group_notify(myDispatchGroup, dispatch_get_main_queue(), ^{ 
      dispatch_release(myDispatchGroup); 
      [self parsingCompleteWithActivity:activity]; 
    }); 
} 

Bonne chance!