Conserver le cycle sur «soi» avec des blocs

J'ai bien peur que cette question soit assez basique, mais je pense qu'elle est pertinente pour beaucoup de programmeurs Objective-C qui se retrouvent dans des blocages.

Ce que j'ai entendu, c'est que puisque les blocs capturent les variables locales référencées en leur sein en tant que constcopies, l'utilisation selfdans un bloc peut entraîner un cycle de rétention, si ce bloc est copié. Donc, nous sommes censés utiliser __blockpour forcer le bloc à traiter directement au selflieu de le copier.

__block typeof(self) bself = self;
[someObject messageWithBlock:^{ [bself doSomething]; }];

au lieu de juste

[someObject messageWithBlock:^{ [self doSomething]; }];

Ce que j'aimerais savoir est le suivant: si c'est vrai, y a-t-il un moyen d'éviter la laideur (en dehors de l'utilisation de GC)?

Strictement parlant, le fait qu'il s'agisse d'une copie const n'a rien à voir avec ce problème. Les blocs conserveront toutes les valeurs obj-c capturées lors de leur création. Il se trouve que la solution de contournement pour le problème de copie de const est identique à la solution de contournement pour le problème de conservation; à savoir, en utilisant la __blockclasse de stockage pour la variable.

Dans tous les cas, pour répondre à votre question, il n'y a pas de véritable alternative ici. Si vous concevez votre propre API basée sur des blocs, et que cela a du sens de le faire, vous pouvez faire passer la valeur de selfin en tant qu'argument. Malheureusement, cela n'a pas de sens pour la plupart des API.

Veuillez noter que le référencement d'un ivar pose exactement le même problème. Si vous avez besoin de référencer un ivar dans votre bloc, utilisez plutôt une propriété ou utilisez bself->ivar.

Addendum: lors de la compilation en tant qu'ARC, les __blockinterruptions de cycle de conservation ne sont plus. Si vous compilez pour ARC, vous devez utiliser __weakou à la __unsafe_unretainedplace.

Utilisez simplement:

__weak id weakSelf = self;

[someObject someMethodWithBlock:^{
    [weakSelf someOtherMethod];
}];

Pour plus d'informations: WWDC 2011 - Blocks and Grand Central Dispatch in Practice .

https://developer.apple.com/videos/wwdc/2011/?id=308

Remarque: si cela ne fonctionne pas, vous pouvez essayer

__weak typeof(self)weakSelf = self;

Cela peut être évident, mais vous n'avez à faire le vilain selfalias que lorsque vous savez que vous obtiendrez un cycle de rétention. Si le bloc est juste une chose ponctuelle, je pense que vous pouvez ignorer en toute sécurité la conservation self. Le mauvais cas est lorsque vous avez le bloc comme interface de rappel, par exemple. Comme ici:

typedef void (^BufferCallback)(FullBuffer* buffer);

@interface AudioProcessor : NSObject {…}
@property(copy) BufferCallback bufferHandler;
@end

@implementation AudioProcessor

- (id) init {
    …
    [self setBufferCallback:^(FullBuffer* buffer) {
        [self whatever];
    }];
    …
}

Ici, l'API n'a pas beaucoup de sens, mais cela aurait du sens lors de la communication avec une superclasse, par exemple. Nous conservons le gestionnaire de tampon, le gestionnaire de tampon nous retient. Comparez avec quelque chose comme ceci:

typedef void (^Callback)(void);

@interface VideoEncoder : NSObject {…}
- (void) encodeVideoAndCall: (Callback) block;
@end

@interface Foo : NSObject {…}
@property(retain) VideoEncoder *encoder;
@end

@implementation Foo
- (void) somewhere {
    [encoder encodeVideoAndCall:^{
        [self doSomething];
    }];
}

Dans ces situations, je ne fais pas d' selfalias. Vous obtenez un cycle de conservation, mais l'opération est de courte durée et le bloc finira par sortir de la mémoire, interrompant le cycle. Mais mon expérience avec les blocs est très petite et il se peut que l' selfaliasing soit une meilleure pratique à long terme.

Publier une autre réponse parce que c'était un problème pour moi aussi. Au départ, je pensais que je devais utiliser blockSelf partout où il y avait une auto-référence à l'intérieur d'un bloc. Ce n'est pas le cas, ce n'est que lorsque l'objet lui-même contient un bloc. Et en fait, si vous utilisez blockSelf dans ces cas, l'objet peut être libéré avant que vous ne récupériez le résultat du bloc, puis il plantera lorsqu'il essaiera de l'appeler, donc clairement vous voulez que le soi soit conservé jusqu'à la réponse revient.

Le premier cas montre quand un cycle de rétention se produira car il contient un bloc référencé dans le bloc:

#import <Foundation/Foundation.h>

typedef void (^MyBlock)(void);

@interface ContainsBlock : NSObject 

@property (nonatomic, copy) MyBlock block;

- (void)callblock;

@end 

@implementation ContainsBlock
@synthesize block = _block;

- (id)init {
    if ((self = [super init])) {

        //__block ContainsBlock *blockSelf = self; // to fix use this.
        self.block = ^{
                NSLog(@"object is %@", self); // self retain cycle
            };
    }
    return self;
}

- (void)dealloc {
    self.block = nil;
    NSLog (@"ContainsBlock"); // never called.
    [super dealloc];
} 

- (void)callblock {
    self.block();
} 

@end 

 int main() {
    ContainsBlock *leaks = [[ContainsBlock alloc] init];
    [leaks callblock];
    [leaks release];
}

Vous n'avez pas besoin de blockSelf dans le second cas car l'objet appelant ne contient pas de bloc qui provoquera un cycle de rétention lorsque vous référencez self:

#import <Foundation/Foundation.h>

typedef void (^MyBlock)(void);

@interface BlockCallingObject : NSObject 
@property (copy, nonatomic) MyBlock block;
@end

@implementation BlockCallingObject 
@synthesize block = _block;

- (void)dealloc {
    self.block = nil;
    NSLog(@"BlockCallingObject dealloc");
    [super dealloc];
} 

- (void)callblock {
    self.block();
} 
@end

@interface ObjectCallingBlockCallingObject : NSObject 
@end

@implementation ObjectCallingBlockCallingObject 

- (void)doneblock {
    NSLog(@"block call complete");
}

- (void)dealloc {
    NSLog(@"ObjectCallingBlockCallingObject dealloc");
    [super dealloc];
} 

- (id)init {
    if ((self = [super init])) {

        BlockCallingObject *myobj = [[BlockCallingObject alloc] init];
        myobj.block = ^() {
            [self doneblock]; // block in different object than this object, no retain cycle
        };
        [myobj callblock];
        [myobj release];
    }
    return self;
}
@end

int main() {

    ObjectCallingBlockCallingObject *myObj = [[ObjectCallingBlockCallingObject alloc] init];
    [myObj release];

    return 0;
} 

Rappelez-vous également que des cycles de rétention peuvent se produire si votre bloc se réfère à un autre objet qui retient ensuite self.

Je ne suis pas sûr que Garbage Collection puisse aider dans ces cycles de conservation. Si l'objet conservant le bloc (que j'appellerai l'objet serveur) survit self(l'objet client), la référence à l' selfintérieur du bloc ne sera pas considérée comme cyclique jusqu'à ce que l'objet de rétention lui-même soit libéré. Si l'objet serveur survit de loin à ses clients, vous pouvez avoir une fuite de mémoire importante.

Puisqu'il n'y a pas de solutions propres, je recommanderais les solutions de contournement suivantes. N'hésitez pas à en choisir un ou plusieurs pour résoudre votre problème.

• Utilisez des blocs uniquement pour la finalisation , et non pour les événements ouverts. Par exemple, utilisez des blocs pour des méthodes comme doSomethingAndWhenDoneExecuteThisBlock:, et non des méthodes commesetNotificationHandlerBlock: . Les blocs utilisés pour l'achèvement ont une fin de vie définie et doivent être libérés par les objets serveur après leur évaluation. Cela empêche le cycle de rétention de vivre trop longtemps même s'il se produit.
• Faites cette danse de référence faible que vous avez décrite.
• Fournissez une méthode pour nettoyer votre objet avant sa sortie, qui "déconnecte" l'objet des objets serveur qui peuvent lui contenir des références; et appelez cette méthode avant d'appeler release sur l'objet. Bien que cette méthode soit parfaitement adaptée si votre objet n'a qu'un seul client (ou est un singleton dans un certain contexte), elle s'effondrera s'il a plusieurs clients. Vous êtes en train de vaincre le mécanisme de comptage de retenue ici; cela revient à appeler deallocau lieu de release.

Si vous écrivez un objet serveur, ne prenez les arguments de bloc que pour terminer. N'acceptez pas les arguments de bloc pour les rappels, tels que setEventHandlerBlock:. Au lieu de cela, revenez au modèle de délégué classique: créez un protocole formel et publiez une setEventDelegate:méthode. Ne retenez pas le délégué. Si vous ne souhaitez même pas créer de protocole formel, acceptez un sélecteur comme rappel de délégué.

Et enfin, ce modèle devrait sonner des alarmes:

- (void) dealloc {
    [myServerObject releaseCallbackBlocksForObject: self];
    ...
}

Si vous essayez de décrocher des blocs qui peuvent faire référence selfde l'intérieur dealloc, vous avez déjà des problèmes. deallocpeut ne jamais être appelé en raison du cycle de rétention causé par les références dans le bloc, ce qui signifie que votre objet va simplement fuir jusqu'à ce que l'objet serveur soit désalloué.

__block __unsafe_unretainedles modificateurs suggérés dans l'article de Kevin peuvent provoquer l'exception d'accès incorrect en cas de blocage exécuté dans un thread différent. Il est préférable d'utiliser uniquement le modificateur __block pour la variable temporaire et de le rendre nul après l'utilisation.

__block SomeType* this = self;
[someObject messageWithBlock:^{
  [this doSomething]; // here would be BAD_ACCESS in case of __unsafe_unretained with
                      //  multithreading and self was already released
  this = nil;
}];

Vous pouvez utiliser la bibliothèque libextobjc. Il est assez populaire, il est utilisé dans ReactiveCocoa par exemple. https://github.com/jspahrsummers/libextobjc

Il fournit 2 macros @weakify et @strongify, vous pouvez donc avoir:

@weakify(self)
[someObject messageWithBlock:^{
   @strongify(self)
   [self doSomething]; 
}];

Cela empêche une référence forte directe afin de ne pas entrer dans un cycle de rétention de soi. Et aussi, cela empêche le soi de devenir nul à mi-chemin, mais décrémente toujours correctement le nombre de rétention. Plus d'informations sur ce lien: http://aceontech.com/objc/ios/2014/01/10/weakify-a-more-elegant-solution-to-weakself.html

Que dis-tu de ça?

- (void) foo {
     __weak __block me = self;

     myBlock = ^ {
        [[me someProp] someMessage];
     }
     ...
 }

Je ne reçois plus l'avertissement du compilateur.

Bloc: un cycle de rétention se produira car il contient un bloc référencé dans le bloc; Si vous effectuez la copie de bloc et utilisez une variable membre, self sera conservé.