Всегда передавать слабую ссылку на себя в блок в ARC?

Я немного запутался в использовании блока в Objective-C. В настоящее время я использую ARC, и в моем приложении довольно много блоков, и в настоящее время я всегда ссылаюсь на selfнего вместо его слабой ссылки. Может ли это быть причиной того, что эти блоки сохранили selfи не допустили их освобождения? Вопрос в том, должен ли я всегда использовать weakссылку selfв блоке?

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

Это помогает не сосредоточиться на strongили weakчасти обсуждения. Вместо этого сосредоточьтесь на части цикла .

Сохраняет цикл представляет собой цикл , который происходит , когда объект А сохраняет объект B, и объект Б сохраняет объект A. В этой ситуации, если любой объект выпущен:

• Объект A не будет освобожден, потому что объект B содержит ссылку на него.
• Но Объект B никогда не будет освобожден, пока Объект A имеет ссылку на него.
• Но Объект A никогда не будет освобожден, потому что Объект B содержит ссылку на него.
• до бесконечности

Таким образом, эти два объекта будут просто зависать в памяти на протяжении всей жизни программы, даже если они должны, если все работает правильно, быть освобождены.

Итак, нас беспокоит то, что мы сохраняем циклы , и сами по себе блоки не создают эти циклы. Это не проблема, например:

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

Блок сохраняет self, но selfне сохраняет блок. Если один или другой освобождается, цикл не создается, и все освобождается, как и должно быть.

Где вы попали в беду это что-то вроде:

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

Теперь ваш объект ( self) имеет явную strongссылку на блок. И у блока есть неявная сильная ссылка на self. Это цикл, и теперь ни один объект не будет освобожден должным образом.

Поскольку в подобной ситуации, self по определению, уже имеется strongссылка на блок, обычно ее проще всего решить, сделав явно слабую ссылку selfдля использования блока:

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

Но это не должно быть шаблоном по умолчанию, который вы используете при работе с блоками, которые вызывают self! Это следует использовать только для разрыва того, что в противном случае было бы циклом сохранения между собой и блоком. Если бы вы применили этот шаблон повсюду, вы бы рискнули передать блок чему-то, что было выполнено после 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];
}];

Вам не нужно всегда использовать слабую ссылку. Если ваш блок не сохраняется, но выполняется, а затем отбрасывается, вы можете сильно захватить себя, так как он не создаст цикл сохранения. В некоторых случаях вы даже хотите, чтобы блок удерживал себя до завершения блока, чтобы он не освобождался преждевременно. Однако, если вы захватите блок сильно, а внутри себя захватите, это создаст цикл сохранения.

Я полностью согласен с @jemmons:

Но это не должно быть шаблоном по умолчанию, который вы используете, когда имеете дело с блоками, вызывающими self! Это следует использовать только для разрыва того, что в противном случае было бы циклом сохранения между собой и блоком. Если бы вы использовали этот шаблон повсюду, вы бы рискнули передать блок чему-то, что было выполнено после освобождения 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];
}];

Чтобы преодолеть эту проблему, можно определить сильную ссылку weakSelfвнутри блока:

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

Как указывает Лео, код, который вы добавили в свой вопрос, не предлагал бы сильный ссылочный цикл (иначе, сохранить цикл). Одна из проблем, связанных с операцией, которая может привести к сильному циклу ссылок, может быть, если операция не освобождается. Хотя ваш фрагмент кода предполагает, что вы не определили свою операцию как параллельную, но если она у вас есть, она не будет выпущена, если вы никогда не публиковали isFinished, или если у вас были циклические зависимости или что-то в этом роде. И если операция не будет отменена, контроллер представления также не будет освобожден. Я бы предложил добавить точку останова или метод NSLogвашей операции deallocи подтвердить, что он вызывается.

Ты сказал:

Я понимаю понятие сохранения циклов, но я не совсем уверен, что происходит в блоках, так что это немного смущает меня

Проблемы с циклом сохранения (сильный ссылочный цикл), возникающие с блоками, аналогичны проблемам с циклом сохранения, с которыми вы знакомы. Блок будет поддерживать сильные ссылки на любые объекты, которые появляются внутри блока, и он не будет освобождать эти сильные ссылки, пока сам блок не будет освобожден. Таким образом, если блок ссылается selfили даже просто ссылается на переменную экземпляра self, которая будет поддерживать сильную ссылку на себя, это не разрешается до тех пор, пока блок не будет освобожден (или в этом случае, пока не NSOperationбудет освобожден подкласс.

Для получения дополнительной информации см. Раздел « Избегайте сильных эталонных циклов при захвате себя» в разделе « Программирование с помощью Objective-C: Работа с блоками» .

Если ваш контроллер представления все еще не освобождается, вы просто должны определить, где находится неразрешенная сильная ссылка (при условии, что вы подтвердили, что NSOperationосвобождается). Типичным примером является использование повторения NSTimer. Или некоторый пользовательский delegateили другой объект, который ошибочно поддерживает strongссылку. Вы можете часто использовать Инструменты, чтобы отследить, где объекты получают свои сильные ссылки, например:

Или в Xcode 5:

В некоторых объяснениях игнорируется условие о цикле сохранения [Если группа объектов связана кругом сильных отношений, они поддерживают друг друга, даже если нет сильных ссылок вне группы.] Для получения дополнительной информации прочитайте документ

Вот как вы можете использовать себя внутри блока:

// вызов блока

 NSString *returnedText= checkIfOutsideMethodIsCalled(self);

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


};