Sempre passe uma referência fraca de si para o bloco no ARC?

Estou um pouco confuso sobre o uso de blocos no Objective-C. Atualmente, uso o ARC e tenho muitos bloqueios no meu aplicativo, atualmente sempre se referindo ao selfinvés de sua referência fraca. Essa pode ser a causa desses blocos reter selfe impedir que sejam desalocados? A questão é: devo sempre usar uma weakreferência de selfem um bloco?

-(void)handleNewerData:(NSArray *)arr
{
    ProcessOperation *operation =
    [[ProcessOperation alloc] initWithDataToProcess:arr
                                         completion:^(NSMutableArray *rows) {
        dispatch_async(dispatch_get_main_queue(), ^{
            [self updateFeed:arr rows:rows];
        });
    }];
    [dataProcessQueue addOperation:operation];
}

ProcessOperation.h

@interface ProcessOperation : NSOperation
{
    NSMutableArray *dataArr;
    NSMutableArray *rowHeightsArr;
    void (^callback)(NSMutableArray *rows);
}

ProcessOperation.m

-(id)initWithDataToProcess:(NSArray *)data completion:(void (^)(NSMutableArray *rows))cb{

    if(self =[super init]){
        dataArr = [NSMutableArray arrayWithArray:data];
        rowHeightsArr = [NSMutableArray new];
        callback = cb;
    }
    return self;
}

- (void)main {
    @autoreleasepool {
        ...
        callback(rowHeightsArr);
    }
}

Ajuda a não se concentrar na parte strongou weakna discussão. Em vez disso, concentre-se na parte do ciclo .

Um ciclo de retenção é um loop que ocorre quando o Objeto A retém o Objeto B e o Objeto B retém o Objeto A. Nessa situação, se um dos objetos for liberado:

• O Objeto A não será desalocado porque o Objeto B mantém uma referência a ele.
• Mas o Objeto B nunca será desalocado, desde que o Objeto A tenha uma referência a ele.
• Mas o Objeto A nunca será desalocado porque o Objeto B mantém uma referência a ele.
• ao infinito

Portanto, esses dois objetos permanecerão na memória durante toda a vida útil do programa, mesmo que, se tudo estivesse funcionando corretamente, fossem desalocados.

Então, o que nos preocupa é manter ciclos , e não há nada sobre bloqueios que criem esses ciclos. Isso não é um problema, por exemplo:

[myArray enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop){
   [self doSomethingWithObject:obj];
}];

O bloco retém self, mas selfnão o retém. Se um ou outro é liberado, nenhum ciclo é criado e tudo é desalocado como deveria.

Onde você entra em problemas é algo como:

//In the interface:
@property (strong) void(^myBlock)(id obj, NSUInteger idx, BOOL *stop);

//In the implementation:
[self setMyBlock:^(id obj, NSUInteger idx, BOOL *stop) {
  [self doSomethingWithObj:obj];     
}];

Agora, seu objeto ( self) tem uma strongreferência explícita ao bloco. E o bloco tem uma forte referência implícitaself . Isso é um ciclo, e agora nenhum objeto será desalocado adequadamente.

Como, em uma situação como essa, self por definição já tem uma strongreferência ao bloco, geralmente é mais fácil resolver fazendo uma referência explicitamente fraca selfpara o bloco usar:

__weak MyObject *weakSelf = self;
[self setMyBlock:^(id obj, NSUInteger idx, BOOL *stop) {
  [weakSelf doSomethingWithObj:obj];     
}];

Mas esse não deve ser o padrão padrão que você segue ao lidar com blocos que chamam self! Isso deve ser usado apenas para interromper o que seria um ciclo de retenção entre o eu e o bloco. Se você adotasse esse padrão em qualquer lugar, correria o risco de passar um bloco para algo que foi executado depois que selffoi desalocado.

//SUSPICIOUS EXAMPLE:
__weak MyObject *weakSelf = self;
[[SomeOtherObject alloc] initWithCompletion:^{
  //By the time this gets called, "weakSelf" might be nil because it's not retained!
  [weakSelf doSomething];
}];

Você não precisa sempre usar uma referência fraca. Se o seu bloco não for retido, mas executado e descartado, você poderá se capturar com força, pois não criará um ciclo de retenção. Em alguns casos, você deseja que o bloco se mantenha até a conclusão do bloco, para que não seja desalocado prematuramente. Se, no entanto, você capturar o bloco fortemente, e dentro do self de captura, ele criará um ciclo de retenção.

Concordo totalmente com @jemmons:

Mas esse não deve ser o padrão padrão que você segue ao lidar com blocos que se chamam self! Isso deve ser usado apenas para interromper o que seria um ciclo de retenção entre o eu e o bloco. Se você adotasse esse padrão em qualquer lugar, correria o risco de passar um bloco para algo que foi executado depois que o self foi desalocado.

//SUSPICIOUS EXAMPLE:
__weak MyObject *weakSelf = self;
[[SomeOtherObject alloc] initWithCompletion:^{
  //By the time this gets called, "weakSelf" might be nil because it's not  retained!
  [weakSelf doSomething];
}];

Para superar esse problema, é possível definir uma forte referência sobre o weakSelfinterior do bloco:

__weak MyObject *weakSelf = self;
[[SomeOtherObject alloc] initWithCompletion:^{
  MyObject *strongSelf = weakSelf;
  [strongSelf doSomething];
}];

Como Leo aponta, o código que você adicionou à sua pergunta não sugere um ciclo de referência forte (também conhecido como ciclo de retenção). Um problema relacionado à operação que poderia causar um forte ciclo de referência seria se a operação não estivesse sendo liberada. Embora seu snippet de código sugira que você não definiu sua operação como simultânea, mas, se o tiver, não seria liberada se você nunca publicasse isFinished, ou se tivesse dependências circulares ou algo parecido. E se a operação não for liberada, o controlador de exibição também não será liberado. Sugiro adicionar um ponto de interrupção ou NSLogno deallocmétodo da sua operação e confirmar que está sendo chamado.

Você disse:

Entendo a noção de ciclos de retenção, mas não sei bem o que acontece em blocos, o que me confunde um pouco

Os problemas do ciclo de retenção (ciclo de referência forte) que ocorrem nos blocos são exatamente como os problemas do ciclo de retenção com os quais você está familiarizado. Um bloco manterá referências fortes a todos os objetos que aparecerem dentro do bloco e não liberará essas referências fortes até que o próprio bloco seja liberado. Portanto, se o bloco referenciar self, ou mesmo apenas referenciar uma variável de instância de self, que manterá forte referência a si mesmo, isso não será resolvido até que o bloco seja liberado (ou nesse caso, até que a NSOperationsubclasse seja liberada).

Para obter mais informações, consulte a seção Evitar ciclos de referência fortes ao capturar a si própria do documento Programação com objetivo-C: Trabalhando com blocos .

Se o seu controlador de visualização ainda não estiver sendo liberado, basta identificar onde reside a referência forte não resolvida (supondo que você confirmou que NSOperationestá sendo desalocado). Um exemplo comum é o uso de uma repetição NSTimer. Ou algum delegateobjeto personalizado ou outro que está mantendo uma strongreferência erroneamente . Muitas vezes, você pode usar o Instruments para rastrear onde os objetos estão recebendo suas referências fortes, por exemplo:

Ou no Xcode 5:

Algumas explicações ignoram uma condição sobre o ciclo de retenção. [Se um grupo de objetos estiver conectado por um círculo de relacionamentos fortes, eles se manterão vivos, mesmo que não haja referências fortes fora do grupo.] Para obter mais informações, leia o documento

É assim que você pode usar o self dentro do bloco:

// chamada do bloco

 NSString *returnedText= checkIfOutsideMethodIsCalled(self);

NSString* (^checkIfOutsideMethodIsCalled)(*)=^NSString*(id obj)
{
             [obj MethodNameYouWantToCall]; // this is how it will call the object 
            return @"Called";


};