ส่งการอ้างอิงตนเองที่อ่อนแอไปยังบล็อกใน 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. ในสถานการณ์นั้นถ้าวัตถุใดถูกปล่อยออกมา:

• วัตถุ A จะไม่ถูกจัดสรรคืนเนื่องจาก Object B เก็บการอ้างอิงไว้
• แต่วัตถุ B จะไม่ถูกยกเลิกการจัดสรรตราบใดที่วัตถุ A มีการอ้างอิงถึงมัน
• แต่จะไม่ถูกยกเลิกการจัดสรรวัตถุ 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จะปล่อยคลาสย่อย

สำหรับข้อมูลเพิ่มเติมดูส่วนหลีกเลี่ยงการอ้างอิงที่รัดกุมเมื่อจับตัวเองของส่วนเขียนโปรแกรมด้วย 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";


};