Reter o ciclo no `self 'com blocos

Receio que essa pergunta seja bastante básica, mas acho relevante para muitos programadores de Objective-C que estão entrando em blocos.

O que ouvi é que, como os blocos capturam variáveis ​​locais referenciadas como constcópias, o uso selfdentro de um bloco pode resultar em um ciclo de retenção, caso esse bloco seja copiado. Portanto, devemos usar __blockpara forçar o bloco a lidar diretamente, em selfvez de copiá-lo.

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

em vez de apenas

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

O que eu gostaria de saber é o seguinte: se isso for verdade, existe uma maneira de evitar a feiura (além de usar o GC)?

Estritamente falando, o fato de ser uma cópia const não tem nada a ver com esse problema. Os blocos reterão quaisquer valores obj-c capturados quando criados. Acontece que a solução alternativa para o problema de cópia constante é idêntica à solução alternativa para o problema de retenção; ou seja, usando o__block classe de armazenamento para a variável

De qualquer forma, para responder sua pergunta, não há alternativa real aqui. Se você estiver projetando sua própria API baseada em bloco e fizer sentido, poderá fazer com que o bloco passe o valor de selfin como argumento. Infelizmente, isso não faz sentido para a maioria das APIs.

Observe que a referência a um ivar tem exatamente o mesmo problema. Se você precisar fazer referência a um ivar no seu bloco, use uma propriedade ou use bself->ivar.

Adendo: Ao compilar como ARC, as __blockquebras não retêm mais ciclos. Se você estiver compilando para o ARC, precisará usar __weakou em __unsafe_unretainedvez disso.

Apenas use:

__weak id weakSelf = self;

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

Para mais informações: WWDC 2011 - Blocos e expedição da Grand Central na prática .

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

Nota: se isso não funcionar, você pode tentar

__weak typeof(self)weakSelf = self;

Isso pode ser óbvio, mas você só precisa fazer o selfalias feio quando sabe que terá um ciclo de retenção. Se o bloqueio é apenas uma coisa, acho que você pode ignorar com segurança a retenção self. O caso ruim é quando você tem o bloco como uma interface de retorno de chamada, por exemplo. Como aqui:

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

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

@implementation AudioProcessor

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

Aqui, a API não faz muito sentido, mas faria sentido ao se comunicar com uma superclasse, por exemplo. Nós retemos o manipulador de buffer, o manipulador de buffer nos mantém. Compare com algo como isto:

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];
    }];
}

Nessas situações, eu não faço o selfalias. Você obtém um ciclo de retenção, mas a operação tem vida curta e o bloco fica sem memória eventualmente, interrompendo o ciclo. Mas minha experiência com blocos é muito pequena e pode ser que o selfaliasing seja uma prática recomendada a longo prazo.

Postando outra resposta, porque isso também foi um problema para mim. Originalmente, pensei que tinha que usar blockSelf em qualquer lugar onde houvesse uma auto-referência dentro de um bloco. Não é esse o caso, é apenas quando o próprio objeto possui um bloco. E, de fato, se você usar o blockSelf nesses casos, o objeto poderá ser desalocado antes que você obtenha o resultado de volta do bloco e depois travará quando tentar chamá-lo, tão claramente você deseja que seja retido até a resposta volta.

O primeiro caso demonstra quando um ciclo de retenção ocorrerá porque contém um bloco que é referenciado no bloco:

#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];
}

Você não precisa blockSelf no segundo caso, porque o objeto de chamada não possui um bloco que causará um ciclo de retenção quando você fizer referência a si próprio:

#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;
} 

Lembre-se também de que podem ocorrer ciclos de retenção se o seu bloco se referir a outro objeto que então retém self.

Não tenho certeza de que a coleta de lixo possa ajudar nesses ciclos de retenção. Se o objeto que retém o bloco (que chamarei de objeto servidor) sobrevive self(o objeto cliente), a referência aself dentro do bloco não será considerada cíclica até que o próprio objeto retentor seja liberado. Se o objeto do servidor sobreviver a seus clientes, você pode ter um vazamento de memória significativo.

Como não há soluções limpas, eu recomendaria as seguintes soluções alternativas. Sinta-se à vontade para escolher um ou mais deles para corrigir seu problema.

• Use blocos apenas para conclusão , e não para eventos abertos. Por exemplo, use blocos para métodos como doSomethingAndWhenDoneExecuteThisBlock:, e não métodos comosetNotificationHandlerBlock: . Os blocos usados ​​para conclusão têm fins de vida definidos e devem ser liberados pelos objetos do servidor após serem avaliados. Isso impede que o ciclo de retenção viva por muito tempo, mesmo que ocorra.
• Faça aquela dança de referência fraca que você descreveu.
• Forneça um método para limpar seu objeto antes que ele seja lançado, que "desconecta" o objeto dos objetos do servidor que podem conter referências a ele; e chame esse método antes de chamar release no objeto. Embora esse método seja perfeitamente adequado se seu objeto tiver apenas um cliente (ou for um singleton em algum contexto), mas será quebrado se tiver vários clientes. Você está basicamente derrotando o mecanismo de contagem de retenção aqui; isso é semelhante a ligar em deallocvez de release.

Se você estiver escrevendo um objeto de servidor, use argumentos de bloco apenas para conclusão. Não aceite argumentos de bloco para retornos de chamada, como setEventHandlerBlock:. Em vez disso, volte ao padrão clássico de delegação: crie um protocolo formal e anuncie um setEventDelegate:método. Não retenha o delegado. Se você nem deseja criar um protocolo formal, aceite um seletor como retorno de chamada delegado.

E, por último, esse padrão deve tocar alarmes:

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

Se você está tentando desengatar os blocos que podem se referir selfde dentro dealloc, já está com problemas. deallocnunca pode ser chamado devido ao ciclo de retenção causado pelas referências no bloco, o que significa que seu objeto simplesmente vazará até que o objeto do servidor seja desalocado.

__block __unsafe_unretainedmodificadores sugeridos na postagem de Kevin podem causar a exceção de acesso incorreto no caso de bloco executado em um thread diferente. É melhor usar apenas o modificador __block para a variável temp e torná-lo nulo após o uso.

__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;
}];

Você pode usar a biblioteca libextobjc. É bastante popular, é usado no ReactiveCocoa, por exemplo. https://github.com/jspahrsummers/libextobjc

Ele fornece 2 macros @weakify e @strongify, para que você possa ter:

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

Isso evita uma referência direta forte, para que não entremos em um ciclo de retenção para si próprio. E também evita que o eu se torne nulo no meio do caminho, mas ainda diminui adequadamente a contagem de retenção. Mais neste link: http://aceontech.com/objc/ios/2014/01/10/weakify-a-more-elegant-solution-to-weakself.html

Que tal agora?

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

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

Não recebo mais o aviso do compilador.

Bloco: um ciclo de retenção ocorrerá porque contém um bloco que é referenciado no bloco; Se você copiar o bloco e usar uma variável de membro, o self será retido.