Ios – Does NSURLSession Take place in a separate thread

grand-central-dispatchiosnsurlsessionobjective c

I was designing an app that uses NSURLSession and thinking about putting it in a different thread with Grand Central Dispatch, but if NSURLSession automatically does that in the background, I wouldn't have to use GCD then, correct?

So in other words, does NSURLSession automatically use Grand Central Dispatch in the background, so we don't have to worry about it?

Best Answer

Yes,

NSURLSession (URLSession in Swift) does its work in a background thread. The download ALWAYS takes place asynchronously on a background thread.

EDIT:

There is no reason to wrap your code that invokes NSURLSession (or URLSession in Swift 3 or later) in a GCD call.

You can control whether its completion methods are executed on a background thread or not by the queue you pass in in the delegateQueue parameter to the init method. If you pass in nil, it creates a (background thread) serial operation queue where your completion methods are called. If you pass in NSOperationQueue.mainQueue() (OperationQueue.mainQueue() in recent versions of Swift) then your completion delegate methods/closures will be invoked on the main thread and you won't have to wrap UI calls in dispatch_async() calls to the main thread.

Related Solutions

Objective-c – Do you need to create an NSAutoreleasePool within a block in GCD

Does the same rule apply to a block that is placed within a Grand Central Dispatch queue and will be run on a non-main thread? That is, do you need to create an NSAutoreleasePool within each block you dispatch to anything other than the main queue?

Grand central dispatch will manage an autorelease pool per queue automatically. However, there are no guarantees as to when the pool will be drained; it may be after one block is processed, it may be after hundreds (but probably won't be).

So, if you are only allocating a few objects, don't worry about it. However, if you are allocating any significant number of objects (and since you are targeting a memory constrained environment), then you should be creating and draining pools.

The documentation has been updated.

See https://developer.apple.com/library/content/documentation/General/Conceptual/ConcurrencyProgrammingGuide/OperationQueues/OperationQueues.html#//apple_ref/doc/uid/TP40008091-CH102-SW1

If your block creates more than a few Objective-C objects, you might want to enclose parts of your block’s code in an @autorelease block to handle the memory management for those objects. Although GCD dispatch queues have their own autorelease pools, they make no guarantees as to when those pools are drained. If your application is memory constrained, creating your own autorelease pool allows you to free up the memory for autoreleased objects at more regular intervals.

Ios – iPhone – Grand Central Dispatch main thread

Dispatching a block to the main queue is usually done from a background queue to signal that some background processing has finished e.g.

- (void)doCalculation
{
    //you can use any string instead "com.mycompany.myqueue"
    dispatch_queue_t backgroundQueue = dispatch_queue_create("com.mycompany.myqueue", 0);

    dispatch_async(backgroundQueue, ^{
        int result = <some really long calculation that takes seconds to complete>;

        dispatch_async(dispatch_get_main_queue(), ^{
            [self updateMyUIWithResult:result];
        });    
    });
}

In this case, we are doing a lengthy calculation on a background queue and need to update our UI when the calculation is complete. Updating UI normally has to be done from the main queue so we 'signal' back to the main queue using a second nested dispatch_async.

There are probably other examples where you might want to dispatch back to the main queue but it is generally done in this way i.e. nested from within a block dispatched to a background queue.

background processing finished -> update UI
chunk of data processed on background queue -> signal main queue to start next chunk
incoming network data on background queue -> signal main queue that message has arrived
etc etc

As to why you might want to dispatch to the main queue from the main queue... Well, you generally wouldn't although conceivably you might do it to schedule some work to do the next time around the run loop.

Best Answer

EDIT:

Related Solutions

Objective-c – Do you need to create an NSAutoreleasePool within a block in GCD

Ios – iPhone – Grand Central Dispatch main thread

Related Topic