Will self be retained when send message to it - ios

Question

TestObj class is a simple class that has a method doSomethingInBackground in which I send it performSelectorInBackground method to make itself sleep 5 seconds in background thread.
#implementation TestObj
- (void)dealloc
{
NSLog(#"%#, is main thread %u", NSStringFromSelector(_cmd), [NSThread isMainThread]) ;
}
- (void)doSomethingInBackground
{
[self performSelectorInBackground:#selector(backgroundWork) withObject:nil] ;
}
- (void)backgroundWork
{
sleep(5) ;
}
#end
I alloc and init the instance and send it doSomethingInBackground message and assign nil to it in order to release it as soon as possible.
TestObj *obj = [[TestObj alloc] init] ;
[obj doSomethingInBackground] ;
obj = nil ;
I find that the dealloc will run after about 5 seconds obj = nil;, it seems that system retains self when send it the method [self performSelectorInBackground:#selector(backgroundWork) withObject:nil] ; and after backgroundWork returned, the instance will be deallocated.
Can anyone tell me the works that system do behind this. Thanks.

Answer 1

-[NSObject performSelectorInBackground:withObject:] under the hood calls -[NSThread initWithTarget:selector:object:] which does retain the original receiver (here passed as target parameter)
NSThread documentation: "The objects target and argument are retained during the execution of the detached thread. They are released when the thread finally exits."

Answer 2

From the Docs,
The performSelectorInBackground:withObject: method creates a new detached thread and uses the specified method as the entry point for the new thread. For example, if you have some object (represented by the variable myObj) and that object has a method called doSomething that you want to run in a background thread, you could use the following code to do that:
[myObj performSelectorInBackground:#selector(doSomething) withObject:nil];
The effect of calling this method is the same as if you called the detachNewThreadSelector:toTarget:withObject: method of NSThread with the current object, selector, and parameter object as parameters. The new thread is spawned immediately using the default configuration and begins running.
In the detachNewThreadSelector:toTarget:withObject: documentation,
The objects aTarget and anArgument are retained during the execution
of the detached thread, then released. The detached thread is exited
(using the exit class method) as soon as aTarget has completed
executing the aSelector method.
Regarding the performSelector:AfterDelay: ,
This method sets up a timer to perform the aSelector message on the
current thread’s run loop. The timer is configured to run in the
default mode (NSDefaultRunLoopMode). When the timer fires, the thread
attempts to dequeue the message from the run loop and perform the
selector. It succeeds if the run loop is running and in the default
mode; otherwise, the timer waits until the run loop is in the default
mode
And
The timer maintains a strong reference to this object until it (the
timer) is invalidated.
If you do not want your Obj to be retained, you can use a weak referenced object,
TestObj *obj = [[TestObj alloc] init] ;
__weak typeof(obj) weakObj = obj;
[weakObj doSomethingInBackground] ;
obj = nil ;

Answer 3

While special cases like performSelector: have been discussed in other answers I think it's helpful to add the answer to the general case:
Will self be retained when send message to it
No. In both manual retain count and ARC self is never implicitly retained. You must take care that the receiver of a message is not deallocated during method execution.
While under ARC self's type is strong the object is not actually retained. See the ARC documentation.