Como funciona o pool de liberação automática NSAutoreleasePool?

Pelo que entendi, qualquer coisa criada com uma alocação , nova ou cópia precisa ser liberada manualmente. Por exemplo:

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

Minha pergunta, porém, é que isso não seria tão válido ?:

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

Sim, seu segundo trecho de código é perfeitamente válido.

Cada vez que -autorelease é enviado a um objeto, ele é adicionado ao pool de autorelease mais interno. Quando o pool é drenado, ele simplesmente envia -release para todos os objetos no pool.

Os pools de liberação automática são simplesmente uma conveniência que permite adiar o envio de liberação para "mais tarde". Esse "mais tarde" pode acontecer em vários lugares, mas o mais comum em aplicativos Cocoa GUI é no final do ciclo de loop de execução atual.

NSAutoreleasePool: drenagem vs. liberação

Visto que a função de draine releaseparece estar causando confusão, pode valer a pena esclarecer aqui (embora isso seja abordado na documentação ...).

Estritamente falando, da perspectiva do quadro geral nãodrain é equivalente a :release

Em um ambiente de contagem de referência, drainexecuta as mesmas operações que release, portanto, os dois são equivalentes nesse sentido. Para enfatizar, isso significa que você não vaza uma piscina se usar em drainvez de release.

Em um ambiente com coleta de lixo, releaseé um ambiente autônomo. Portanto, não tem efeito. drain, por outro lado, contém uma dica para o coletor de que ele deve "coletar se necessário". Portanto, em um ambiente com coleta de lixo, o uso drainajuda o sistema a equilibrar as varreduras de coleta.

Como já apontado, seu segundo trecho de código está correto.

Eu gostaria de sugerir uma maneira mais sucinta de usar o pool de autorelease que funciona em todos os ambientes (contagem de ref, GC, ARC) e também evita a confusão de drenagem / liberação:

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

No exemplo acima, observe o bloco @autoreleasepool . Isso está documentado aqui .

Não, você está errado. A documentação afirma claramente que sob não-GC, -drain é equivalente a -release, o que significa que o NSAutoreleasePool não vazará.

O que li da Apple: "No final do bloco do pool de autorelease, os objetos que receberam uma mensagem de autorelease dentro do bloco recebem uma mensagem de release - um objeto recebe uma mensagem de release para cada vez que foi enviada uma mensagem de autorelease dentro do bloco. "

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

enviar liberação automática em vez de liberação para um objeto estende a vida útil desse objeto pelo menos até que o próprio pool seja drenado (pode ser mais longo se o objeto for retido posteriormente). Um objeto pode ser colocado no mesmo pool várias vezes e, nesse caso, ele recebe uma mensagem de liberação para cada vez que foi colocado no pool.

Sim e não. Você acabaria liberando a memória da string, mas "vazando" o objeto NSAutoreleasePool na memória usando drenagem em vez de liberação se executasse isso em um ambiente de coleta de lixo (não gerenciado por memória). Esse "vazamento" simplesmente torna a instância de NSAutoreleasePool "inacessível" como qualquer outro objeto sem ponteiros fortes em GC, e o objeto seria limpo na próxima vez que GC fosse executado, o que poderia muito bem ser diretamente após a chamada para -drain:

drenar

Em um ambiente com coleta de lixo, aciona a coleta de lixo se a memória alocada desde a última coleta for maior que o limite atual; caso contrário, se comporta como liberação. ... Em um ambiente com coleta de lixo, esse método finalmente chama objc_collect_if_needed.

Caso contrário, é semelhante ao -releasecomportamento em não-GC, sim. Como outros afirmaram, -releaseé um ambiente autônomo no GC, então a única maneira de garantir que o pool funcione corretamente no GC é através -drain, e -drainno não-GC funciona exatamente como -releaseno não-GC, e pode-se dizer que comunica sua funcionalidade mais claramente conforme bem.

Devo ressaltar que sua instrução "qualquer coisa chamada com new, aloc ou init" não deve incluir "init" (mas deve incluir "copiar"), porque "init" não aloca memória, apenas configura o objeto (construtor moda). Se você recebeu um objeto alocado e sua função apenas chamada init como tal, você não o liberaria:

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

Isso não consome mais memória do que você já começou (assumindo que o init não instancia objetos, mas você não é responsável por eles).