<div>Hello all,</div><div><br></div><div>I&#39;m encountering a behavior around object lifetime and deinitialization that is surprising to me.  Here&#39;s an approximation of what I&#39;m encountering:</div><div><br></div><div>I have a class Handle whose deinit must execute on a certain queue (let&#39;s call it q--in my case it is a global queue).  I have a second class AsyncHandle which owns a Handle and needs to be able to deinit on any queue.  There&#39;s a tension to resolve between the deinitialization contracts of Handle and AsyncHandle.  To resolve it, in AsyncHandle&#39;s deinit, I am binding the owned instance of Handle to a local variable, dispatching async onto the q, and from the async closure, calling extendLifetime with the Handle, where extendLifetime is the following:</div><div><br></div><div>@inline(never) func extendLifetime&lt;T : AnyObject&gt;() {}</div><div><br></div><div>AsyncHandle&#39;s deinit looks like</div><div><br></div><div>deinit {</div><div>    let handle = self.handle</div><div>    q.async {</div><div>        extendLifetime(handle)</div><div>    }</div><div>}</div><div><br></div><div>This approach seems to work--the Handle gets deinit on q, the appropriate queue.  Most of the time.  In the debugger, there is never a problem.  Occasionally and inconsistently, on some devices, I am, however, seeing a behavior that _seems_ to be the synchronous deallocation of Handle from AsyncHandle&#39;s deinit on the queue that AsyncHandle happens to be deinitializing on (not q).  If that is indeed, the behavior I&#39;m seeing, I do not understand why it is happening.</div><div><br></div><div>A few questions:</div><div>(1) Given an object B owned (exclusively--no other objects have references to A) by an object A, is it legal to extend the lifetime of B in the deinit of A?  (It might conceivably not be legal if there is a rule such as the following: when the runtime observes that an object R referenced by a field of a deinitializing object O has a reference count of one, it assumes that R must die when O dies and consequently puts R into some moribund state from which there is no revivification.)</div><div>(2) If it is legal, is calling extendLifetime from a dispatch async the appropriate way to do it?</div><div>(3) Is my &quot;implementation&quot; (such as it is) of extendLifetime correct?  (I can&#39;t use the stdlib&#39;s _fixLifetime, unfortunately, or even implement extendLifetime in the same way.)</div><div>(4) Does optimization based on visibility enter into this?  In my case the AsyncHandle is fileprivate.</div><div>(5) Is there any entirely different approach to satisfy the following requirements?  (a) AsyncHandle be releasable/deinitializable on any thread.  (b) Handle be deinitialized only on some dispatch queue q.  (c) AsyncHandle has the only reference to Handle.</div><div><br></div><div>Thank you very much,</div><div>Nate Chandler</div><div><br></div>