appel performSelectorInBackground: à partir du thread d'arrière-plan

Question

Quel est l'effet réel d'appeler performSelectorInBackground:... à partir d'une méthode qui s'exécute en arrière-plan? Je veux qu'il fonctionne de manière asynchrone

Par exemple:

- (void) _imageBufferWasUpdated{ 
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; 

    //do something here 

    if(shouldContinue){ 
     [self performSelectorInBackground:@selector(_loop) withObject:nil]; 
    } 
    [pool release]; 
} 

_imageBufferWasUpdated fonctionnera en arrière-plan et je veux appeler _loop méthode de manière asynchrone (en arrière-plan aussi si _imageBufferWasUpdated se terminera bientôt, probablement avant _loop fin) .

Est-ce correct?

Existe-t-il une manière plus efficace (et relativement simple) de faire cela en utilisant GCD? Je vous serais reconnaissant si vous pouviez donner un exemple sur la façon de fourche cela en utilisant GCD. Je pense que j'ai besoin d'au moins 3 threads, thread principal, fil d'arrière-plan pour exécuter _imageBufferWasUpdated et autre thread d'arrière-plan pour _loop. Ai-je raison?

Merci à l'avance Ignacio

Answer 1

Ce que vous faites me semble bien. Cocoa utilise probablement un seul thread d'arrière-plan, donc cela ne devrait pas conduire à une création excessive de threads.

Si vous souhaitez plus de contrôle, vous pouvez utiliser NSOperation ou GCD. Les deux sont assez simples. Par exemple, GCD serait comme ceci

#import <dispatch/dispatch.h> 

... 

dispatch_async(dispatch_get_global_queue(0,0), ^{ 
    [self _loop]; 
}]; 

Answer 2

fourches performSelectorInBackground votre sélecteur sur un fil d'arrière-plan. [documentation]

Je ne sais pas si j'ai raison, mais vous devriez tout faire en utilisant GCD ou ses classes de haut niveau (NSOperationQueue). La fourchette trop de threads d'arrière-plan peut entraîner une diminution des performances si le système est saturé avec trop de threads et n'a pas assez de ressources de calcul

GCD gère automatiquement le nombre de threads qui fonctionnent simultanément en fonction des ressources système disponibles.