Mit schwachen selbst in dispatch_async Funktion

Vorausgesetzt, selbst ist ein Zeiger auf ein Objekt, um eine UIViewController.

Dinge zu beachten:

• Einen UIViewController ist ein "UIKit" - Objekt. UIKit Gegenstände dürfen nicht gesendet werden Methoden, die auf nicht-Haupt-threads, das ist - diese Methoden müssen auf dem primären thread ausgeführt nur!

• Einen block, wurde in die Warteschlange eingereiht in eine Warteschlange - ob synchron oder asynchron - werden schließlich ausgeführt -- egal was! Gut, wenn das Programm beendet wird, bevor dies geschehen kann.

• Erfasst retainable starke Zeiger werden beibehaltenwenn der block kopiert werden (zum Beispiel, wenn asynchron ausgelöst), und wieder veröffentlichtwenn der block zerstört wird (nachdem es fertig ist).

• Erfasst retainable schwach Zeiger werden NICHT gespeichert und nicht veröffentlicht.

In Ihrem Szenario, wo Sie erfassen selbst in den block, das ausgelöst wird, auf die main queueSie brauchen keine sorgen zu machen, dass schlimme Dinge passieren.

So, warum? Und was passiert tatsächlich?

Seit selbst werden erfasst in den block, die ausgelöst wird asynchronselbst implizit beibehaltenund veröffentlicht wieder, wenn der block fertig ist.

Das bedeutet, die Lebens-Zeit von selbst werden erweitert bis nach dem block beendet. Beachten Sie, dass Ihre zweiten block ausgelöst, auf die Haupt-threadund es ist garantiert, dass selbst ist noch am Leben, wenn der block ausgeführt wird.

Diese "extended life" vor, könnte eine gewünschte Funktion von Ihrem Programm.

Wenn Sie explizit will nicht verlängern die Lebensdauer der UIViewController Objekt, und stattdessen wollen die block - als es schließlich ausgeführt wird - überprüfenob diese UIViewController Objekt noch vorhanden ist, können Sie mit einer __weak pointer von selbst. Beachten Sie, dass der block wird schließlich ausgeführt, egal ob die UIViewController ist noch am Leben oder wurde freigegeben in der Zwischenzeit.

Möchten Sie vielleicht den block tun "nichts", wenn die UIViewController wurde freigegeben vor der block wird ausgeführt:

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

Siehe auch: Der übergang zum ARC Release Notes

Denken Sie daran: UIKit Objekte wird nicht gesendet Methoden auf nicht-Haupt-threads!

Einer anderen subtilen Fehler kann auftreten, tun, um die Tatsache, dass UIKit Objekte sind Methoden ausführen, nur auf dem Haupt-thread.

Dieser kann verletzt sein, wenn ein block fängt ein UIKit Objekt, das asynchron ausgelöst, und führt auf eine nicht-Haupt - thread. Dann kann es passieren, dass der block hält die letzten starken Hinweis auf, dass UIKit Objekt. Nun, wenn der block wird schließlich ausgeführt, wird der block zerstört, und der UIKit Objekt freigegeben wird. Da dies die Letzte starke Verweis auf die UIKit Objekt, wird es freigegeben. Dies geschieht jedoch auf den thread, in dem der block ausgeführt wurde - und dies ist nicht der Haupt-thread! Nun, schlimme Dinge können (und werden normalerweise) passieren kann, da die dealloc Methode ist immer noch eine Methode, an einen UIKit Objekt.

Können Sie diesen Fehler vermeiden, durch die Entsendung von einem block erfassen einen starken Zeiger auf das UIKit-Objekt, und senden Sie eine dummy-Methode:

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

In Ihrem Szenario obwohl, die Letzte starke Referenz werden könnte, nur in dem block, der ausgeführt wird auf dem Haupt-thread. Ja, sind Sie sicher von dieser subtilen Fehler. 😉

Edit:

In Ihrem setup, Sie haben nie einen retain-Zyklus. Ein retain-Zyklus tritt auf, wenn ein retainable Objekt stark auf ein anderes retainable Objekt B und Objekt B dringend Referenzen A. Beachten Sie, dass ein "Block" ist auch ein retainable Objekt.

Ein erfundenes Beispiel mit einer zyklischen Referenz:

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

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

Hier, wir haben eine Eigenschaft, die Abschlussderen Wert Typ ist ein Block. Das heißt, wir bekommen ein ivar mit dem Namen _completion deren Typ ein Block.

Client kann einen completion handler, die aufgerufen werden soll, wenn eine bestimmte operation abgeschlossen hat. Angenommen, der Betrieb holt sich eine Liste von Benutzern von einem remote-server. Der plan ist, setzen Sie die Eigenschaft Benutzer sobald die operation beendet:

Den unvorsichtigen Ansatz könnte versehentlich die Einführung einer zyklischen Referenz:

Irgendwo in "UsersViewController.m"

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

[self fetchUsers];  //start asynchronous task

Hier selbst hat einen starken Bezug auf die ivar _completiondas ist ein block. Und der block selbst erfasst selbstdie Ursachen zu behalten selbstwenn der block wird kopiert, wenn es ausgelöst wird. Dies ist eine klassische Referenz-Zyklus.

Um zu vermeiden, dass die zyklische Referenz, haben wir ein paar alternativen:

1. Mit einem __weak qualifizierte Zeiger der selbst

   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. Mit einem __block qualifizierte Zeiger der selbst und schließlich es nil im block, wenn es fertig ist:

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

Siehe auch: Der übergang zum ARC Release Notes

InformationsquelleAutor der Antwort CouchDeveloper