Używanie słabego self w funkcji asynchronicznej wysyłania

Zakładając, self jest wskaźnikiem obiektu do UIViewController.

Rzeczy do rozważenia:

• A UIViewController jest obiektem "UIKit". Obiekty UIKit nie mogą być wysyłane metodami w wątkach innych niż główne, czyli - metody te muszą być wykonywane tylko w głównym wątku!

• Blok, który został zapytany w kolejce - czy to był synchronicznie czy asynchronicznie - zostanie ostatecznie wykonany - bez względu na wszystko! No chyba, że program się zakończy zanim to się stanie.

• Przechwycone retainable silne wskaźniki zostaną zachowane , gdy blok zostanie skopiowany (na przykład, gdy zostanie wysłany asynchronicznie), i ponownie zwolnione , gdy blok zostanie zniszczony (po jego zakończeniu).

• Przechwycone utrzymywalne słabe wskaźniki nie zostaną zatrzymane i nie zostaną zwolnione.

W Twoim scenariuszu, gdzie uchwycisz siebie w bloku, który jest wysyłane w kolejce głównej , nie musisz się martwić, że złe rzeczy się zdarzają.

Ponieważ self zostanie przechwycony w bloku, który jest wysyłany asynchronicznie, self zostanie w domyśle zatrzymane, a zwolnione ponownie po zakończeniu bloku.

Oznacza to, że czas życia siebie będzie przedłużony aż do wykończenia bloków. Zauważ, że twój drugi blok jest wysyłany do głównego wątku i masz gwarancję, że self będzie nadal żywy, gdy blok zostanie wykonany.

Powyższa "przedłużona żywotność" może być pożądaną cechą twojego programu.

Jeśli jawnie nie chcesz przedłużać czasu życia obiektu UIViewController, a zamiast tego chcesz, aby blok-kiedy w końcu zostanie wykonany - sprawdź czy ten obiekt {6]} nadal istnieje w wszystko, można użyć _ _ słaby wskaźnik jaźni. Zauważ, że blok zostanie ostatecznie wykonany, bez względu na to, czy UIViewController jest nadal żywy, czy został dealokowany w międzyczasie.

Możesz chcieć, aby blok robił "nic", Jeśli UIViewController został dealokowany przed blok zostanie wykonany:

MyController* __weak weakSelf = self;
dispatch_async(queue, ^{
    MyController* strongSelf = weakSelf;
    if (strongSelf) {
        ...
    }
    else {
       // self has been deallocated in the meantime.
    }
});

Zobacz także: przejście do informacji o wydaniu ARC

Pamiętaj: UIKit obiekty nie powinny być wysyłane metodami w wątkach innych niż główne!

Jeden inny subtelny błąd może wynikać z faktu, że UIKit obiekty powinny wykonywać metody tylko w głównym wątku.

Można uniknąć tego błędu, wysyłając blok przechwytujący silny wskaźnik do tego obiektu UIKit i wysyłając do niego metodę atrapy:

UIViewController* strongUIKitPointer = ... 
dispatch_async(non_main_queue, ^{
    ... // do something 
    dispatch(dispatch_get_main_queue(), ^{
        [strongUIKitPointer self];  // note: self is a method, too - doing nothing
    });
});

W Twoim scenariuszu, ostatni strong reference może być tylko w bloku, który wykonuje się w głównym wątku. Więc jesteście bezpieczni od tego subtelnego błędu. ;)

Edit:

W konfiguracji nigdy nie masz cyklu zachowywania. Cykl zachowywania występuje, gdy obiekt A silnie odwołuje się do innego obiektu B, A obiekt B silnie odwołuje się do A. zauważ, że "blok" jest również obiektem dającym się utrzymać.

Wymyślony przykład z cyklicznym odniesieniem:

typedef void(^my_completion_block_t)(NSArray* result);

@interface UsersViewController : UIViewController
@property (nonatomic, copy) my_completion_block_t completion;
@property (nonatomic) NSArray* users;
@end

Tutaj mamy nieruchomość dopełnienie którego typem wartości jest blok. Oznacza to, że otrzymujemy ivar o nazwie _completion, którego typem jest blok.

Klient może ustawić obsługę zakończenia, która powinna być wywołana po zakończeniu określonej operacji. Załóżmy, że operacja pobiera listę użytkowników ze zdalnego serwera. Plan polega na ustawieniu właściwości users Po zakończeniu operacji:

Nieostrożne podejście przypadkowo wprowadziłoby cykliczne odniesienie:

Gdzieś w "UsersViewController.m "

self.completion = ^(NSArray* users){
    self.users = users;
}

[self fetchUsers];  // start asynchronous task

Tutaj, self posiada silne odniesienie do ivar _completion, który jest blokiem. I sam blok przechwytuje self, co powoduje zachowanie self, gdy blok zostanie skopiowany, gdy zostanie wysłany. To klasyczny cykl odniesienia.

1. Używając __weak kwalifikowanego wskaźnika self

   UsersViewController* __weak weakSelf = self;
   self.completion = ^(NSArray* users) {
       UsersViewController* strongSelf = weakSelf;
       if (strongSelf) {
           strongSelf.users = users;
       }
       else {
           // the view controller does not exist anymore
       }
   }   
   [usersViewController fetchUsers];
   

2. Użycie __block kwalifikowanego wskaźnika self i ostatecznie ustawienie go nil w bloku po jego zakończeniu:

   UsersViewController* __block blockSelf = self;
   self.completion = ^(NSArray* users) {
       blockSelf.users = users;
       blockSelf = nil;
   }   
   [usersViewController fetchUsers];
   

Zobacz także: przejście do informacji o wydaniu ARC