¿Siempre pasa la referencia débil de uno mismo al bloque en ARC?

Estoy un poco confundido sobre el uso de bloques en Objective-C. Actualmente uso ARC y tengo bastantes bloques en mi aplicación, actualmente siempre me refiero en selflugar de su referencia débil. ¿Puede ser esa la causa de que estos bloques selfretengan y eviten que sean desalojados? La pregunta es, ¿debería usar siempre una weakreferencia de selfen un bloque?

-(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);
    }
}

Ayuda a no centrarse en parte strongo weaken la discusión. En cambio, concéntrate en la parte del ciclo .

Un ciclo de retención es un ciclo que ocurre cuando el Objeto A retiene el Objeto B, y el Objeto B retiene el Objeto A. En esa situación, si cualquiera de los objetos se libera:

• El objeto A no se desasignará porque el objeto B tiene una referencia a él.
• Pero el Objeto B nunca será desasignado mientras el Objeto A tenga una referencia a él.
• Pero el Objeto A nunca será desasignado porque el Objeto B tiene una referencia a él.
• indefinidamente

Por lo tanto, esos dos objetos permanecerán en la memoria durante toda la vida del programa, aunque deberían, si todo funcionara correctamente, ser desasignado.

Entonces, lo que nos preocupa es retener ciclos , y no hay nada sobre los bloques en sí mismos que crean estos ciclos. Esto no es un problema, por ejemplo:

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

El bloque retiene self, pero selfno retiene el bloque. Si se libera uno u otro, no se crea ningún ciclo y todo se desasigna como debería.

Donde te metes en problemas es 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];     
}];

Ahora, su objeto ( self) tiene una strongreferencia explícita al bloque. Y el bloque tiene una fuerte referencia implícita a self. Eso es un ciclo, y ahora ninguno de los objetos se desasignará correctamente.

Porque, en una situación como esta, self por definición ya tiene una strongreferencia al bloque, generalmente es más fácil de resolver haciendo una referencia explícitamente débil selfpara que el bloque use:

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

¡Pero este no debería ser el patrón predeterminado que sigues cuando trates con bloques que llaman self! Esto solo debe usarse para romper lo que de otro modo sería un ciclo de retención entre uno mismo y el bloque. Si adoptara este patrón en todas partes, correría el riesgo de pasar un bloque a algo que se ejecutó después de que selffue desasignado.

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

No tiene que usar siempre una referencia débil. Si su bloqueo no se retiene, sino que se ejecuta y luego se descarta, puede capturarse con fuerza, ya que no creará un ciclo de retención. En algunos casos, incluso desea que el bloque se retenga hasta que se complete el bloque para que no se desasigne prematuramente. Sin embargo, si captura el bloque con fuerza, y dentro de sí mismo, creará un ciclo de retención.

Estoy totalmente de acuerdo con @jemmons:

¡Pero este no debería ser el patrón predeterminado que sigues cuando trates con bloques que se autodenominan! Esto solo debe usarse para romper lo que de otro modo sería un ciclo de retención entre uno mismo y el bloque. Si adoptara este patrón en todas partes, correría el riesgo de pasar un bloque a algo que se ejecutó después de que se desasignara el self.

//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 este problema, se puede definir una referencia fuerte sobre el weakSelfinterior del bloque:

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

Como Leo señala, el código que agregó a su pregunta no sugeriría un ciclo de referencia fuerte (también conocido como ciclo de retención). Un problema relacionado con la operación que podría causar un fuerte ciclo de referencia sería si la operación no se libera. Si bien su fragmento de código sugiere que no ha definido su operación como concurrente, pero si lo ha hecho, no se publicará si nunca publicó isFinished, o si tuvo dependencias circulares, o algo así. Y si la operación no se lanza, el controlador de vista tampoco se lanzaría. Sugeriría agregar un punto de interrupción o NSLogen el deallocmétodo de su operación y confirmar que se llama.

Tu dijiste:

Entiendo la noción de retener ciclos, pero no estoy muy seguro de lo que sucede en los bloques, así que eso me confunde un poco

Los problemas del ciclo de retención (ciclo de referencia fuerte) que ocurren con los bloques son como los problemas del ciclo de retención con los que está familiarizado. Un bloque mantendrá referencias fuertes a cualquier objeto que aparezca dentro del bloque, y no liberará esas referencias fuertes hasta que se libere el bloque mismo. Por lo tanto, si las referencias de bloque self, o incluso solo hace referencia a una variable de instancia de self, que mantendrá una fuerte referencia a sí mismo, eso no se resolverá hasta que se libere el bloque (o en este caso, hasta que NSOperationse libere la subclase.

Para obtener más información, consulte la sección Evitar ciclos de referencia fuertes al capturar uno mismo del documento Programación con Objective-C: Trabajar con bloques .

Si su controlador de vista aún no se está lanzando, simplemente tiene que identificar dónde reside la referencia fuerte no resuelta (suponiendo que confirmó que NSOperationse está desasignando). Un ejemplo común es el uso de una repetición NSTimer. O algún delegateobjeto personalizado u otro que mantiene erróneamente una strongreferencia. A menudo puede usar instrumentos para rastrear dónde los objetos obtienen sus referencias fuertes, por ejemplo:

O en Xcode 5:

Algunas explicaciones ignoran una condición sobre el ciclo de retención [Si un grupo de objetos está conectado por un círculo de relaciones fuertes, se mantienen vivos incluso si no hay referencias fuertes desde fuera del grupo.] Para obtener más información, lea el documento

Así es como puedes usar el self dentro del bloque:

// llamada del bloque

 NSString *returnedText= checkIfOutsideMethodIsCalled(self);

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


};