ios - How long does an autoreleased static object declared globally, survive in memory? -

if declare static object handle in class file in global scope. , object assigned handle autoreleased one. how long object remain in memory during application life cycle ?

if declare static object handle in class file in global scope. , object assigned handle autoreleased one. how long object remain in memory during application life cycle?

short answer: want global strong reference. in mrc, must add retains , releases globals. in arc, global implicitly strong (and arc adds them you).

long answer: under arc, static global variable strong reference. in mrc, retain such variable when set , release previous object. if did not, still access after deallocated (dangling pointer).

because strong reference, object remain valid until a) strong reference global variable given , b) autorelease pool drained c) , of course other strong references given up.

so if using strong references global , never reassign (logically, giving global's strong reference), object never dealloc'ed.

when use unsafe nonretained semantics (by decoration in arc, or default static in mrc), object -dealloced when current autorelease pool drained , strong references removed. easiest illustrate program (mrc);

static monobject * globalobject; // // in mrc, must add reference counting ensure not end dangling // pointer, false how program should written in mrc. // // in arc, program nonretainedownership because treats global // strong reference. static const bool nonretainedownership = ...t/f...;  ...  // assume globalobject accessed 1 thread -- won't bother // supporting code illustrate how should made thread safe. - (monobject *)sharedobject {  if (nil == globalobject) {   if (nonretainedownership) {       // don't this! lifetime determined strong client references       // , reference rely on lost when thread's current       // autorelease pool drained -- leaving dangling pointer       // cause issues when -sharedobject called again.     globalobject = [[monobject new] autorelease];   }   else {      // - keep strong reference:    globalobject = [monobject new];   }  }  return globalobject; }  - (void)disposesharedobject {  if (nonretainedownership) {   globalobject = nil;  }  else {   // remove our reference, established @ [monobject new]   // assuming there no strong external references, object   // dealloc'ed -- should not make assumption   // if return it.   [globalobject release], globalobject = nil;  } } 

so if nonretainedownership true , use mrc, object typically -dealloc-ed shortly after -sharedobject returns (assuming whoever called -sharedobject holds no strong reference). in case, 'shortly' means pool drained few frames in current callstack, in appkit or uikit when on main thread since don't see many people explicitly create autorelease pools on main thread. borrrden said after "1/60th of second", , assumption there object created , autoreleased in main thread's run loop (correct me if wrong). 'kits create autorelease pools @ each iteration of main run loop, program running on secondary thread or there inner autorelease pool, lifetime has possibility shorter or longer. normally, don't need think these things in depth -- use strong reference here since have no other way ensure right thing happens global variable.

if wrote: @autoreleasepool{[[monobject new] autorelease];} nslog("hi"); object (under normal circumstances) released time nslog called.