Zawsze przekazujesz słabe odniesienie do siebie do bloku w ARC?

Jestem trochę zdezorientowany co do użycia bloku w Objective-C. Obecnie używam ARC i mam dość dużo bloków w mojej aplikacji, obecnie zawsze odnoszących się do selfzamiast jej słabego odniesienia. Czy może to być przyczyną zatrzymania selfi zablokowania bloków przed zwolnieniem? Pytanie brzmi: czy zawsze powinienem używać weakodniesienia selfw bloku?

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

Pomaga nie koncentrować się na dyskusji strongani jej weakczęści. Zamiast tego skup się na części cyklu .

Cykl zatrzymania to pętla, która zachodzi, gdy Obiekt A zachowuje Obiekt B, a Obiekt B zachowuje Obiekt A. W takiej sytuacji, jeśli dowolny obiekt zostanie zwolniony:

• Obiekt A nie zostanie zwolniony, ponieważ Obiekt B zawiera odniesienie do niego.
• Ale Obiekt B nigdy nie zostanie zwolniony, dopóki Obiekt A ma do niego odniesienie.
• Ale Obiekt A nigdy nie zostanie zwolniony, ponieważ Obiekt B zawiera odniesienie do niego.
• ad infinitum

Tak więc te dwa obiekty będą po prostu wisiały w pamięci przez cały czas trwania programu, mimo że powinny, jeśli wszystko działałoby poprawnie, zostać zwolnione.

Dlatego martwimy się o zachowanie cykli , a same bloki nie mają nic wspólnego z tymi cyklami. To nie jest problem, na przykład:

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

Blok zachowuje self, ale selfnie zachowuje bloku. Jeśli jedno lub drugie zostanie zwolnione, cykl nie zostanie utworzony i wszystko zostanie zwolnione tak, jak powinno.

W kłopoty jest coś takiego:

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

Teraz twoja selffunkcja ( ) ma jawne strongodniesienie do bloku. I blok ma ukryte silne odniesienie do self. To cykl, a teraz żaden obiekt nie zostanie odpowiednio zwolniony.

Ponieważ w takiej sytuacji self z definicji istnieje już strongodwołanie do bloku, zwykle najłatwiej go rozwiązać, tworząc wyraźnie słabe odwołanie do selfbloku:

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

Ale nie powinien to być domyślny wzorzec, który stosujesz w przypadku bloków, które wywołują self! Powinno to być użyte tylko do przerwania tego, co w innym przypadku byłoby cyklem zatrzymania między sobą a blokiem. Jeśli wszędzie zastosujesz ten wzorzec, ryzykujesz przekazaniem bloku do czegoś, co zostało wykonane po selfzwolnieniu.

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

Nie zawsze musisz używać słabego odniesienia. Jeśli twój blok nie zostanie zachowany, ale zostanie wykonany, a następnie odrzucony, możesz mocno przechwycić siebie, ponieważ nie utworzy to cyklu zatrzymania. W niektórych przypadkach chcesz nawet, aby blok utrzymywał siebie do momentu ukończenia bloku, aby nie przedwcześnie zwolnił. Jeśli jednak silnie przechwycisz blok, a wewnątrz siebie przechwytywanie utworzy cykl zatrzymania.

Całkowicie zgadzam się z @jemmons:

Ale nie powinien to być domyślny wzorzec, który stosujesz w przypadku bloków nazywających się self! Powinno to być użyte tylko do przerwania tego, co w innym przypadku byłoby cyklem zatrzymania między sobą a blokiem. Jeśli wszędzie zastosujesz ten wzorzec, ryzykujesz przekazaniem bloku do czegoś, co zostało wykonane po zwolnieniu samego siebie.

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

Aby rozwiązać ten problem, można zdefiniować silne odniesienie weakSelfwewnątrz bloku:

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

Jak zauważa Leo, kod dodany do pytania nie sugerowałby silnego cyklu odniesienia (inaczej: zachowaj cykl). Jednym z problemów związanych z operacją, które mogłyby spowodować silny cykl odniesienia, byłby brak zwolnienia operacji. Chociaż fragment kodu sugeruje, że nie zdefiniowałeś operacji jako współbieżnej, ale jeśli tak, to nie zostanie zwolniony, jeśli nigdy nie opublikujesz wiadomości isFinished, nie będziesz mieć zależności cyklicznych lub czegoś podobnego. A jeśli operacja nie zostanie zwolniona, kontroler widoku również nie zostanie zwolniony. Sugerowałbym dodanie punktu przerwania lub metody NSLogoperacji dealloci potwierdzenie, że zostanie wywołany.

Powiedziałeś:

Rozumiem pojęcie zatrzymania cykli, ale nie jestem całkiem pewien, co dzieje się w blokach, więc trochę mnie to dezorientuje

Problemy z cyklem przechowywania (silny cykl odniesienia) występujące w blokach są podobne do problemów z cyklem przechowywania, które znasz. Blok zachowa silne odwołania do wszelkich obiektów pojawiających się w bloku i nie zwolni tych silnych odniesień, dopóki sam blok nie zostanie zwolniony. Tak więc, jeśli odwołania do bloku self, a nawet po prostu odwołują się do zmiennej instancji self, która zachowa silne odniesienie do siebie, to nie zostanie rozwiązane, dopóki blok nie zostanie zwolniony (lub w tym przypadku, dopóki nie NSOperationzostanie zwolniona podklasa).

Aby uzyskać więcej informacji, zobacz temat Unikanie silnych cykli odniesienia podczas przechwytywania części własnej programowania z dokumentem Cel-C: Praca z blokami .

Jeśli kontroler widoku nadal nie jest uwalniany, musisz po prostu określić, gdzie znajduje się nierozwiązane silne odwołanie (zakładając, że potwierdziłeś, że NSOperationjest on zwolniony). Typowym przykładem jest użycie powtarzania NSTimer. Lub jakiś niestandardowy delegatelub inny obiekt, który błędnie utrzymuje strongodniesienie. Często można używać przyrządów do śledzenia miejsc, w których obiekty uzyskują silne referencje, np .:

Lub w Xcode 5:

Niektóre wyjaśnienia ignorują warunek dotyczący cyklu przechowywania [Jeśli grupa obiektów jest połączona kręgiem silnych relacji, utrzymują się one przy życiu, nawet jeśli nie ma żadnych silnych referencji spoza grupy.] Aby uzyskać więcej informacji, przeczytaj dokument

Oto jak możesz użyć self wewnątrz bloku:

// wywołanie bloku

 NSString *returnedText= checkIfOutsideMethodIsCalled(self);

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


};