ARC und autorelease

Unterschied zwischen ARC und autorelease erklärt-code :

ARC :

-somefunc {
  id obj = [NSArray array];
  NSLog(@"%@", obj);
  //ARC now calls release for the first object

  id obj2 = [NSArray array];
  NSLog(@"%@", obj2);
  //ARC now calls release for the second object
}

Autorelease :

-somefunc {
  id obj = [NSArray array];
  NSLog(@"%@", obj);

  id obj2 = [NSArray array];
  NSLog(@"%@", obj2);
}
//Objects are released some time after this

Grundsätzlich ARC funktioniert, sobald eine variable nicht mehr benutzt wird, in einem Bereich, während autorelease wartet, bis es erreicht die main-loop und ruft dann release auf alle Objekte im pool. ARC verwendet wird innen Umfang, autorelease verwendet wird außerhalb der Gültigkeitsbereich der Funktion.

InformationsquelleAutor Tom van der Woerdt

autorelease noch unter ARC. ARC macht den call für Sie und ist clever zu Kurzschluss. Hier ist eine demonstration , wie genau das funktioniert, das werde ich kopieren Sie hier für den Fall, dass blog-post immer verschwindet; alle fälligen Kredit von Matt Galloway.

So betrachten Sie die folgende Methode:

void foo() {
    @autoreleasepool {
        NSNumber *number = [NSNumber numberWithInt:0];
        NSLog(@"number = %p", number);
    }
}

Dies ist völlig gekünstelt, natürlich, aber Sie sollten lassen Sie uns sehen, was
Los. In nicht-ARC land würden wir nehmen hier an, dass die Zahl wäre
zugeordnet innen numberWithInt: und kehrte autoreleased. Also, wenn der
autorelease pool wird weiter abgelassen, es wird veröffentlicht. Also lasst uns sehen, wenn
das ist, was passiert ist (wie üblich, dies ist ARMv7-Instruktionen):

    .globl  _foo
    .align  2
    .code   16
    .thumb_func     _foo
_foo:
    push    {r4, r7, lr}
    add     r7, sp, #4
    blx     _objc_autoreleasePoolPush
    movw    r1, :lower16:(L_OBJC_SELECTOR_REFERENCES_-(LPC0_0+4))
    movs    r2, #0
    movt    r1, :upper16:(L_OBJC_SELECTOR_REFERENCES_-(LPC0_0+4))
    mov     r4, r0
    movw    r0, :lower16:(L_OBJC_CLASSLIST_REFERENCES_$_-(LPC0_1+4))
LPC0_0:
    add     r1, pc
    movt    r0, :upper16:(L_OBJC_CLASSLIST_REFERENCES_$_-(LPC0_1+4))
LPC0_1:
    add     r0, pc
    ldr     r1, [r1]
    ldr     r0, [r0]
    blx     _objc_msgSend
    mov     r1, r0
    movw    r0, :lower16:(L__unnamed_cfstring_-(LPC0_2+4))
    movt    r0, :upper16:(L__unnamed_cfstring_-(LPC0_2+4))
LPC0_2:
    add     r0, pc
    blx     _NSLog
    mov     r0, r4
    blx     _objc_autoreleasePoolPop
    pop     {r4, r7, pc}

Gut, ja. Das ist genau das, was passiert. Wir können sehen, dass der Aufruf
schieben Sie ein autorelease pool dann einen Anruf zu numberWithInt: dann wird ein Aufruf von
pop einen autorelease pool. Genau das, was wir erwarten würden. Schauen wir uns jetzt an
der exakt gleiche code kompiliert unter ARC:

    .globl  _foo
    .align  2
    .code   16
    .thumb_func     _foo
_foo:
    push    {r4, r5, r7, lr}
    add     r7, sp, #8
    blx     _objc_autoreleasePoolPush
    movw    r1, :lower16:(L_OBJC_SELECTOR_REFERENCES_-(LPC0_0+4))
    movs    r2, #0
    movt    r1, :upper16:(L_OBJC_SELECTOR_REFERENCES_-(LPC0_0+4))
    mov     r4, r0
    movw    r0, :lower16:(L_OBJC_CLASSLIST_REFERENCES_$_-(LPC0_1+4))
LPC0_0:
    add     r1, pc
    movt    r0, :upper16:(L_OBJC_CLASSLIST_REFERENCES_$_-(LPC0_1+4))
LPC0_1:
    add     r0, pc
    ldr     r1, [r1]
    ldr     r0, [r0]
    blx     _objc_msgSend
    @ InlineAsm Start
    mov     r7, r7          @ marker for objc_retainAutoreleaseReturnValue
    @ InlineAsm End
    blx     _objc_retainAutoreleasedReturnValue
    mov     r5, r0
    movw    r0, :lower16:(L__unnamed_cfstring_-(LPC0_2+4))
    movt    r0, :upper16:(L__unnamed_cfstring_-(LPC0_2+4))
    mov     r1, r5
LPC0_2:
    add     r0, pc
    blx     _NSLog
    mov     r0, r5
    blx     _objc_release
    mov     r0, r4
    blx     _objc_autoreleasePoolPop
    pop     {r4, r5, r7, pc}

Beachten Sie die Aufrufe objc_retainAutoreleasedReturnValue und
objc_release. Was dort passiert, ist, dass die ARC hat sich für uns bestimmt
dass es nicht wirklich brauchen, um über den autorelease-pool, s
im Ort, denn es kann einfach sagen, den autorelease nicht passieren
(mit dem Aufruf objc_retainAutoreleasedReturnValue) und dann loslassen
das Objekt später selbst. Dies ist wünschenswert, da es bedeutet, dass der autorelease
Logik muss nicht passieren.

Beachten Sie, dass der autorelease-pool ist erforderlich, um die geschoben werden und
geknallt, weil ARC nicht wissen können, was Los ist in der Anrufe an
numberWithInt: NSLog und zu wissen, wenn Objekte in den pool
es. Wenn er wusste, dass Sie nicht autorelease etwas dann es
könnte tatsächlich loszuwerden, der push und pop. Vielleicht diese Art von
Logik wird in zukünftigen Versionen, ich bin mir zwar nicht ganz sicher, wie das
die Semantik, die funktionieren würde, aber.

Nun betrachten wir ein weiteres Beispiel, das ist, wo wir wollen, zu verwenden
Zahl außerhalb des Bereichs der autorelease-pool zu blockieren. Dies sollte
zeigen Sie uns, warum ARC ist ein Wunder, mit zu arbeiten. Betrachten Sie den folgenden code:

void bar() {
    NSNumber *number;
    @autoreleasepool {
        number = [NSNumber numberWithInt:0];
        NSLog(@"number = %p", number);
    }
    NSLog(@"number = %p", number);
}

Könnten Sie (zu Recht) denken, dass dies zu Problemen führen
obwohl es sieht ganz unbedenklich. Es ist ein problem, weil
Nummer innerhalb der autorelease-pool zu blockieren, werden
freigegeben, wenn der autorelease-pool öffnet, das aber dann nach es
schon ausgeplant. Uh oh! Mal sehen, ob wir richtig durch kompilieren
ohne ARC aktiviert:

    .globl  _bar
    .align  2
    .code   16
    .thumb_func     _bar
_bar:
    push    {r4, r5, r6, r7, lr}
    add     r7, sp, #12
    blx     _objc_autoreleasePoolPush
    movw    r1, :lower16:(L_OBJC_SELECTOR_REFERENCES_-(LPC1_0+4))
    movs    r2, #0
    movt    r1, :upper16:(L_OBJC_SELECTOR_REFERENCES_-(LPC1_0+4))
    mov     r4, r0
    movw    r0, :lower16:(L_OBJC_CLASSLIST_REFERENCES_$_-(LPC1_1+4))
LPC1_0:
    add     r1, pc
    movt    r0, :upper16:(L_OBJC_CLASSLIST_REFERENCES_$_-(LPC1_1+4))
LPC1_1:
    add     r0, pc
    ldr     r1, [r1]
    ldr     r0, [r0]
    blx     _objc_msgSend
    movw    r6, :lower16:(L__unnamed_cfstring_-(LPC1_2+4))
    movt    r6, :upper16:(L__unnamed_cfstring_-(LPC1_2+4))
LPC1_2:
    add     r6, pc
    mov     r5, r0
    mov     r1, r5
    mov     r0, r6
    blx     _NSLog
    mov     r0, r4
    blx     _objc_autoreleasePoolPop
    mov     r0, r6
    mov     r1, r5
    blx     _NSLog
    pop     {r4, r5, r6, r7, pc}

Offensichtlich keine Anrufe zu erhalten, release oder autorelease als wir erwarten würden
da wir nicht alle ausdrücklich, und wir sind nicht mit ARC. Wir können
hier sehen Sie, dass es kompiliert wurde, genau wie wir erwarten würden, von unserer
Argumentation vor. Also mal sehen, was es sieht aus wie beim ARC gibt uns eine
helfende hand:

    .globl  _bar
    .align  2
    .code   16
    .thumb_func     _bar
_bar:
    push    {r4, r5, r6, r7, lr}
    add     r7, sp, #12
    blx     _objc_autoreleasePoolPush
    movw    r1, :lower16:(L_OBJC_SELECTOR_REFERENCES_-(LPC1_0+4))
    movs    r2, #0
    movt    r1, :upper16:(L_OBJC_SELECTOR_REFERENCES_-(LPC1_0+4))
    mov     r4, r0
    movw    r0, :lower16:(L_OBJC_CLASSLIST_REFERENCES_$_-(LPC1_1+4))
LPC1_0:
    add     r1, pc
    movt    r0, :upper16:(L_OBJC_CLASSLIST_REFERENCES_$_-(LPC1_1+4))
LPC1_1:
    add     r0, pc
    ldr     r1, [r1]
    ldr     r0, [r0]
    blx     _objc_msgSend
    @ InlineAsm Start
    mov     r7, r7          @ marker for objc_retainAutoreleaseReturnValue
    @ InlineAsm End
    blx     _objc_retainAutoreleasedReturnValue
    movw    r6, :lower16:(L__unnamed_cfstring_-(LPC1_2+4))
    movt    r6, :upper16:(L__unnamed_cfstring_-(LPC1_2+4))
LPC1_2:
    add     r6, pc
    mov     r5, r0
    mov     r1, r5
    mov     r0, r6
    blx     _NSLog
    mov     r0, r4
    blx     _objc_autoreleasePoolPop
    mov     r0, r6
    mov     r1, r5
    blx     _NSLog
    mov     r0, r5
    blx     _objc_release
    pop     {r4, r5, r6, r7, pc}

Runde Applaus für BOGEN bitte! Beachten Sie, dass es ist erkannt, wir sind
mit der Anzahl der außerhalb des Geltungsbereichs der autorelease-pool blockieren, so
es behielt den Rückgabewert von numberWithInt: so wie damals
vor, aber dieses mal ist es angebracht release am Ende der bar
Funktion eher als vor dem autorelease-pool tauchte. Das wird
gerettet haben uns einen Absturz in einigen code, den wir möglicherweise gedacht haben, war
richtig, aber eigentlich hatte eine subtile memory management Fehler.

InformationsquelleAutor Alex Curylo