Завжди передавати слабке посилання на себе в блок в 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частині. Замість цього зосередьтеся на частині циклу .

Цикл утримування - це цикл, який відбувається, коли Об'єкт A зберігає Об'єкт B, а Об'єкт B зберігає Об'єкт А. У цій ситуації, якщо випускається будь-який об'єкт:

• Об'єкт A не буде розміщений, оскільки об'єкт B містить посилання на нього.
• Але Об'єкт B ніколи не буде розміщений до тих пір, поки Об'єкт А не має посилання на нього.
• Але Об'єкт A ніколи не буде розміщений, оскільки Об'єкт B має посилання на нього.
• ad infinitum

Таким чином, ці два об’єкти просто будуть зависати в пам'яті протягом життя програми, навіть якщо вони, якщо все працює належним чином, мають бути розміщені.

Отже, ми хвилюємось - це збереження циклів , і немає нічого про блоки самі по собі, які створюють ці цикли. Це не проблема, наприклад:

[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:

Але це не повинно бути типовим шаблоном, якого ви дотримуєтесь, коли маєте справу з блоками, які викликають самості! Це слід використовувати лише для того, щоб порушити те, що в іншому випадку було б циклом утримування між "я" та блоком. Якби ви прийняли цю схему скрізь, ви ризикували б передати блок до чогось, що виконується після розселення самоврядування.

//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підкласу.

Для отримання додаткової інформації див. Уникнення сильних еталонних циклів під час зйомки самостійного розділу Програмування за допомогою Цілі-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";


};