Gerenciamento de memória de objeto Singleton

Question

No meu código, uso um objeto Singleton como um ponto central no meu aplicativo para carregar e cache imagens que o aplicativo precisa frequentemente, para que não precise fazer alocação de memória com recursos intensivos cada vez que carrego uma imagem.

Mas há momentos durante a execução do meu aplicativo em que o uso da memória fica intenso e eu gostaria de lançar os dados da imagem em cache. Atualmente, estou apenas lançando as instâncias da UIImage do meu singleton quando recebo um aviso de memória.

Eu preferiria, no entanto, poder liberar todo o objeto Singleton. Isso é possível? Se sim, como?

Answer 1

Claro que é. Embora seja bastante provável que o uso de memória desse objeto seja insignificante em comparação com as imagens.

Pela natureza de um singleton, você precisa ter um acessador para ele, onde criará se não existir: atualmente:

+ (MySingletonClass*) mySingleton
{
    if ( mySingleton == nil )
    {
        mySingleton = [[MySingletonClass alloc] init];
    }

    return mySingleton;
}

Você só precisa adicionar outro que você chama quando deseja destruí -lo:

+ (void) destroyMySingleton
{
    [mySingleton release];
    mySingleton = nil;
}

Se você mantiver referências a ele em outro lugar, terá problemas; Não faça isso. Se você acessar vários threads, precisará sincronizar. Caso contrário, é bem direto - o getter recriará quando você precisar.

Answer 2

Aqui está um exemplo de acessador de singleton para o código de abertura que estou usando.

  // Eric Wing. Singleton accessor.  This is how you should ALWAYS get
  // a reference to the sound controller.  Never init your own.
  + (OpenALSoundController*) sharedController
 {
  static OpenALSoundController* shared_sound_controller;
  @synchronized(self)
  {
   if (nil == shared_sound_controller)
    {
     shared_sound_controller = [[OpenALSoundController alloc] init];
    }
  }      
  return shared_sound_controller;
 }

O Openal demora um pouco para carregar, portanto, manter uma instância é exatamente o que eu preciso. Com mais de um tópico em jogo (não é a minha situação atualmente, mas quero que meu código seja portado para situações onde esse é o caso), coloquei um bloqueio self. @synchronized(self) faz exatamente isso.

Agora eu alocei a memória, por isso sou responsável por lançá -la. Eu poderia ligar [shared_sound_controller autorelease] no +sharedController O método de acessórios, mas isso pode liberar o controlador mais cedo, principalmente quando tenho mais de um thread e eu chamo o acessador pela primeira vez em um thread que não é o thread principal.

Answer 3

Qualquer objeto que você criar, você pode apenas lançar a qualquer momento. (Presumindo que você crie e defina suas propriedades.)

self.myObject = [[myObjectClass alloc] init];
    // do something with the object
   [self.myObject release];       // anytime that you are not using the object

self.myObject = nil; // will also work if you've set the @property (retain, nonatomic)