Come funziona il pool di rilascio automatico di NSAutoreleasePool?

A quanto ho capito, qualsiasi cosa creata con un'allocazione , una nuova o una copia deve essere rilasciata manualmente. Per esempio:

int main(void) {
    NSString *string;
    string = [[NSString alloc] init];
    /* use the string */
    [string release];
}

La mia domanda, però, è che non sarebbe altrettanto valida ?:

int main(void) {
    NSAutoreleasePool *pool;
    pool = [[NSAutoreleasePool alloc] init];
    NSString *string;
    string = [[[NSString alloc] init] autorelease];
    /* use the string */
    [pool drain];
}

Sì, il tuo secondo snippit di codice è perfettamente valido.

Ogni volta che l'autorelease viene inviato a un oggetto, viene aggiunto al pool di autorelease più interno. Quando la piscina viene svuotata, invia semplicemente -release a tutti gli oggetti nella piscina.

I pool di rilascio automatico sono semplicemente una comodità che ti consente di posticipare l'invio del rilascio a "più tardi". Quel "dopo" può verificarsi in diversi punti, ma il più comune nelle app Cocoa GUI è alla fine del ciclo di esecuzione corrente.

NSAutoreleasePool: scarico vs rilascio

Poiché la funzione di draine releasesembra causare confusione, potrebbe valere la pena chiarire qui (sebbene questo sia trattato nella documentazione ...).

A rigor di termini, dal punto di vista del quadro generale nondrain è equivalente a :release

In un ambiente con conteggio dei riferimenti, drainesegue le stesse operazioni di release, quindi i due sono in tal senso equivalenti. Per sottolineare, questo significa che non si perde una piscina se si utilizza drainpiuttosto che release.

In un ambiente raccolto dalla spazzatura, releaseè un no-op. Quindi non ha effetto. drain, d'altra parte, contiene un suggerimento per il collezionista che dovrebbe "raccogliere se necessario". Pertanto, in un ambiente con raccolta dei rifiuti, l'utilizzo drainaiuta il sistema a bilanciare le operazioni di raccolta.

Come già sottolineato, il tuo secondo snippet di codice è corretto.

Vorrei suggerire un modo più succinto di utilizzare il pool di rilascio automatico che funziona su tutti gli ambienti (conteggio ref, GC, ARC) ed evita anche la confusione di scarico / rilascio:

int main(void) {
  @autoreleasepool {
    NSString *string;
    string = [[[NSString alloc] init] autorelease];
    /* use the string */
  }
}

Nell'esempio sopra si prega di notare il blocco @autoreleasepool . Questo è documentato qui .

No, ti sbagli. La documentazione afferma chiaramente che sotto non-GC, -drain è equivalente a -release, il che significa che NSAutoreleasePool non sarà trapelato.

Cosa ho letto da Apple: "Alla fine del blocco del pool di rilascio automatico, agli oggetti che hanno ricevuto un messaggio di rilascio automatico all'interno del blocco viene inviato un messaggio di rilascio: un oggetto riceve un messaggio di rilascio ogni volta che è stato inviato un messaggio di rilascio automatico all'interno del blocco. "

https://developer.apple.com/library/mac/documentation/cocoa/conceptual/MemoryMgmt/Articles/mmAutoreleasePools.html

l'invio del rilascio automatico invece del rilascio a un oggetto estende la durata di quell'oggetto almeno fino a quando il pool stesso non viene svuotato (potrebbe essere più lungo se l'oggetto viene successivamente conservato). Un oggetto può essere inserito più volte nello stesso pool, nel qual caso riceve un messaggio di rilascio ogni volta che è stato inserito nel pool.

Sì e no. Finiresti per rilasciare la memoria di stringa ma "trapelare" l'oggetto NSAutoreleasePool in memoria utilizzando drain invece di release se lo hai eseguito in un ambiente Garbage Collection (non gestito dalla memoria). Questa "perdita" rende semplicemente l'istanza di NSAutoreleasePool "irraggiungibile" come qualsiasi altro oggetto senza puntatori forti sotto GC, e l'oggetto verrebbe ripulito la prossima volta che GC viene eseguito, il che potrebbe benissimo essere direttamente dopo la chiamata a -drain:

scolare

In un ambiente Garbage Collection, attiva la Garbage Collection se la memoria allocata dall'ultima raccolta è maggiore della soglia corrente; altrimenti si comporta come release. ... In un ambiente raccolto dalla spazzatura, questo metodo alla fine chiama objc_collect_if_needed.

Altrimenti, è simile a come -releasesi comporta in condizioni non GC, sì. Come altri hanno affermato, -releaseè un no-op in GC, quindi l'unico modo per assicurarsi che il pool funzioni correttamente in GC è attraverso -drain, e -drainin non-GC funziona esattamente come -releasein non-GC e probabilmente comunica la sua funzionalità più chiaramente come bene.

Vorrei sottolineare che la tua dichiarazione "qualsiasi cosa chiamata con new, alloc o init" non dovrebbe includere "init" (ma dovrebbe includere "copy"), perché "init" non alloca memoria, imposta solo l'oggetto (costruttore moda). Se hai ricevuto un oggetto allocato e la tua funzione si chiama solo init come tale, non lo rilasceresti:

- (void)func:(NSObject*)allocd_but_not_init
{
    [allocd_but_not_init init];
}

Ciò non consuma più memoria di quella con cui hai già iniziato (supponendo che init non installi gli oggetti, ma non sei comunque responsabile di quelli).