Attendre jusqu'à ce que de multiples réseaux demandes ont toutes exécutées - y compris l'achèvement des blocs

J'ai de multiples opérations (ils sont AFNetworking demandes) avec l'achèvement des blocs qui prend un certain temps à s'exécuter, et une Base de Données de l'objet qui doit être sauvé à la fin de tous les les demandes.

MyCoreDataObject *coreDataObject;

AFHTTPRequestOperation *operation1 = [[AFHTTPRequestOperation alloc] initWithRequest:request1];
[operation1 setCompletionBlockWithSuccess:^(AFHTTPRequestOperation *operation, id responseObject) {
    coreDataObject.attribute1 = responseObject;
    sleep(5);
}];
[operation1 start];

AFHTTPRequestOperation *operation2 = [[AFHTTPRequestOperation alloc] initWithRequest:request1];
[operation2 setCompletionBlockWithSuccess:^(AFHTTPRequestOperation *operation, id responseObject) {
    coreDataObject.attribute2 = responseObject;
    sleep(10);
}];
[operation1 operation2];

[context save:nil];

Bien sûr, cela ne fonctionne pas comme je veux, parce que les demandes sont asynchrones. J'ai essayé d'ajouter un NSOperationQueue comme suit:

NSOperationQueue *operationQueue = [[NSOperationQueue alloc] init];
[operationQueue setMaxConcurrentOperationCount:2];

AFHTTPRequestOperation *operation1 = [[AFHTTPRequestOperation alloc] initWithRequest:request1];
[operation1 setCompletionBlockWithSuccess:^(AFHTTPRequestOperation *operation, id responseObject) {
    coreDataObject.attribute1 = responseObject;
    sleep(5);
}];
[operationQueue addOperation:operation1];

AFHTTPRequestOperation *operation2 = [[AFHTTPRequestOperation alloc] initWithRequest:request1];
[operation2 setCompletionBlockWithSuccess:^(AFHTTPRequestOperation *operation, id responseObject) {
    coreDataObject.attribute2 = responseObject;
    sleep(10);
}];
[operationQueue addOperation:operation2];

[imageQueue waitUntilAllOperationsAreFinished];
[context save:nil];

Cela ressemble un peu mieux. À l'aide de waitUntilAllOperationsAreFinished, ma file d'attente bloque le thread courant jusqu'à ce que mes demandes sont finis, mais pas jusqu'à ce que mon succès Blocs sont finis, ce qui est vraiment ce dont j'ai besoin.

Aucune idée sur la façon d'atteindre cet objectif dans un bon chemin?

InformationsquelleAutor choise | 2012-05-17

84

Expédition d'utilisation de groupes.
```
dispatch_group_t group = dispatch_group_create();

MyCoreDataObject *coreDataObject;

dispatch_group_enter(group);
AFHTTPRequestOperation *operation1 = [[AFHTTPRequestOperation alloc] initWithRequest:request1];
[operation1 setCompletionBlockWithSuccess:^(AFHTTPRequestOperation *operation, id responseObject) {
    coreDataObject.attribute1 = responseObject;
    sleep(5);
    dispatch_group_leave(group);
}];
[operation1 start];

dispatch_group_enter(group);
AFHTTPRequestOperation *operation2 = [[AFHTTPRequestOperation alloc] initWithRequest:request1];
[operation2 setCompletionBlockWithSuccess:^(AFHTTPRequestOperation *operation, id responseObject) {
    coreDataObject.attribute2 = responseObject;
    sleep(10);
    dispatch_group_leave(group);
}];
[operation2 start];

dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
dispatch_release(group);

[context save:nil];
```
- merci, cela fonctionne bien. je suis également intéressé de savoir si/comment cela pourrait être réalisé sans bloquer le fil. toute idée de ce?
- Euh, que pourriez-vous dire par "attendre jusqu'à ce que de multiples opérations exécutées" si ce n'est pas bloquant le fil? De toute façon, si vous voulez juste pour exécuter un bloc après tout la fin blocs ont exécuté, vous pouvez utiliser dispatch_group_notify(group, queue, ^{ ... }); au lieu de dispatch_group_wait().
- cool! merci!!!!
- Alternativement, vous pouvez renoncer à l'achèvement des blocs sur les opérations individuelles, et il suffit de parcourir dans l'achèvement du lot bloc, en faisant ce que vous avez besoin tout à la fois. De cette façon, ne pas exiger de toute l'expédition finagling.
- renoncer? pas exactement sûr de ce que tu veux dire. avez-vous un exemple
- Ce qui ne fait pas de sens pour moi à propos de cette réponse est la question de threads. Sans doute ce code n'est pas prévu pour le thread principal (puisque vous ne devriez jamais bloc) et dans ce cas il est exécuté dans un thread secondaire. Dans lequel cas, l'appel à dispatch_group_enter est faite sur ce thread secondaire, mais dispatch_group_leave est appelé par AFNetworking sur le thread principal. est le dispatch_group_t objet des threads comme celui-ci? Je reçois se bloque sur l'appel dispatch_group_leave dans le même code.. ?
- Oui, l'envoi de groupe de l'API est thread-safe. Il n'aurait aucun sens si elle n'était pas. Par exemple, ce qui pourrait dispatch_group_wait() attend, depuis que bloque le thread et, si l'API n'est pas thread-safe, rien d'autre pourrait appeler dispatch_group_leave(). Je vous suggère d'ouvrir une nouvelle question pour votre plante, fournissant le code et le plein rapport de crash.
- Imaginez que vous voulez ajouter tous les responseObjects à un NSMutableArray pour la poursuite du traitement une fois toutes les requêtes ont fini. Auriez-vous besoin d'ajouter les appels à[array addObject:] dans un @synchronized bloc ou ce ne sera pas nécessaire?
- Vous devez utiliser une mécanisme de synchronisation lorsque plusieurs threads simultanément l'accès à une mutable collecte et l'un ou plusieurs d'entre eux pourrait être la mutation d'elle. @synchronized est l'un de ces mécanismes. Une série de file d'attente est une autre. Barrière de tâches sur un privé simultané de la file d'attente est une autre. Etc.
- Le deuxième bloc d'attente pour le premier bloc de quitter le groupe avant d'entrer dans le groupe lui-même?
- pas de. Les blocs sont à l'achèvement des blocs. Ils ne sont pas destinés à s'exécuter immédiatement. Quand leur réseau respectif fin des opérations. Ce qui achève la première est imprévisible. En tout cas, il n'y a rien à propos de l'expédition de groupe qui les empêche de s'exécuter simultanément. C'est jusqu'à combien AFHTTPRequestOperation fonctionne sous le capot. Dans tous les cas, les blocs de ne pas entrer dans le groupe. Le groupe est entré (son compteur est incrémenté) avant que les blocs ne sont même créé, a fortiori, défini comme le gestionnaire d'achèvement, a fortiori invoquée. Les blocs de quitter le groupe (décrémenter) à la fin.
- C'est ce que je soupçonnais. J'ai fini par utiliser BFTask, même si je voulais vraiment utiliser une solution native pour mettre en œuvre une sorte de promesse mécanisme. Merci pour le heads up!
InformationsquelleAutor Ken Thomases
15

AFNetworking a conçu la méthode pour ce genre d'opérations, qui fait abstraction de PGCD:

-enqueueBatchOfHTTPRequestOperationsWithRequests:progressBlock:completionBlock:

-enqueueBatchOfHTTPRequestOperations:progressBlock:completionBlock:

Prendre un coup d'oeil à FAQ

InformationsquelleAutor wzs

Je pense à quelque chose comme ceci:

NSMutableArray *mutableOperations = [NSMutableArray array];
for (NSURL *fileURL in filesToUpload) {
    NSURLRequest *request = [[AFHTTPRequestSerializer serializer] multipartFormRequestWithMethod:@"POST" URLString:@"http://example.com/upload" parameters:nil constructingBodyWithBlock:^(id<AFMultipartFormData> formData) {
        [formData appendPartWithFileURL:fileURL name:@"images[]" error:nil];
    }];

    AFHTTPRequestOperation *operation = [[AFHTTPRequestOperation alloc] initWithRequest:request];

    [mutableOperations addObject:operation];
}

NSArray *operations = [AFURLConnectionOperation batchOfRequestOperations:@[...] progressBlock:^(NSUInteger numberOfFinishedOperations, NSUInteger totalNumberOfOperations) {
    NSLog(@"%lu of %lu complete", numberOfFinishedOperations, totalNumberOfOperations);
} completionBlock:^(NSArray *operations) {
    NSLog(@"All operations in batch complete");
}];
[[NSOperationQueue mainQueue] addOperations:operations waitUntilFinished:NO];

référence aux docs: http://cocoadocs.org/docsets/AFNetworking/2.5.0/

InformationsquelleAutor yershuachu

Mes besoins étaient ceux de faire beaucoup de demande à partir d'un tableau de Chaîne de caractères (URL)

func updateSourceData(element: Int) {

    if element > availableUrls.count - 1 {
        return
    }

    let service = SourceDataServiceDao()
    let currentUrl = availableUrls[element]
    service.fooCall(url: currentUrl, completion: { (response, error) -> Void in
        self.updateSourceData(element + 1)
    })

}

Évidemment, de cette façon, les appels sont effectués en cascade, pas de N appels asynchrones.

InformationsquelleAutor Luca Davanzo

Vous devez vous connecter pour publier un commentaire.