A best practice for multithreading within a function that returns a value, Swift

Question

I have a question that might be not specifically about implementation but rather a tip/best practice thing.

I am working on a class in Swift that gets data from an online source in JSON format. I want to have specific methods in this class that connect to the online source and give the result back in a Dictionary type. The function might be like this:

func getListFromOnline()->[String:String]{

    var resultList : [String:String]=[:]
    ...
    /*
    Some HTTP request is sent to the online source with NSURLRequest

    Then I parse the result and assign it to the resultList
    */
    ...

    return resultList
}

What I get right now in this implementation, without the multithreading, the resultList is apparently returned before fetching from the online source is done. Not surprisingly, it leads to failure in the program.

Any idea or tip how I can achieve the opposite? I am a bit confused with multithreading in this instance, because I want to call this public method asynchronously later from another class and I know how to do that, but I don't get how to make the method that returns an argument have multithreading within itself.

Or is it not about multithreading at all and I am not seeing an obvious solution here?

Answer 1

There are three easy and completely expect approaches to this problem in Swift/Objective-C development, and neither of these solutions involve the method returning the value directly. You could write code that waited for the asynchronous part to complete (blocking a thread) and then return the value, and there are cases where this is done in some of Apple's own libraries, but I'm not going to cover the approach, because it's really not that great of an idea.

---

The first approach involves completion blocks.

When our method is going to perform some asynchronous code, we can pass in a block of code to execute whenever the asynchronous work is done. Such a method would look like this:

func asynchStuff(completionHandler: ([String:String]) -> Void) {
   // do asynchronous stuff, building a [String:String]
   let result: [String: String] = // the result we got async
   completionHandler(result)
}

Remember to call completionHandler() on the same thread that asynchStuff was called on. (This example does not demonstrate that.)

---

The second approach involves delegates and protocols.

We need a class to do the asynchronous work. This class will hold a reference to our delegate, which will implement completion methods. First, a protocol:

@objc protocol AsyncDelegate {
    func complete(result: [String:String]
}

Now our async worker:

class AsyncWorker {
    weak var delegate: AsyncDelegate?

    func doAsyncWork() {
        // like before, do async work...
        let result: [String: String] = // the result we got async
        self.delegate?.complete(result)
    }
}

Remember to be certain that we're calling the completion delegate method on the same thread that doAsyncWork() was called on. (This example does not demonstrate that.)

---

The third approach can be done using NSNotificationCenter. The times when this is the appropriate approach are going to be so rare that I'm not even going to bother with even a rudimentary example like I did the other two examples because you should almost certainly be using one of the first two examples in almost every scenario.

---

Which approach you use depends entirely on your specific use case. In Objective-C, I frequently preferred delegation to block based approach (although sometimes blocks are correct), but Swift allows us to pass regular functions/methods as our block argument so it leans me slightly back toward using the block-based approach for Swift, but still, use the right tool for the right job, as always.

---

I wanted to expand this answer to address calling the callback (whether blocks or delegates) on the appropriate thread. I'm not sure if there's a way to do this with GCD still, but we can do it with NSOperationQueues.

func asyncStuff(completionHandler: ([String:String]) -> Void) {
    let currentQueue = NSOperationQueue.currentQueue()
    someObject.doItsAsyncStuff(someArg, completion: { 
        result: [String:String] in
        currentQueue.addOperationWithBlock() {
            completionHandler(result)
        }
    }
}

Answer 2

Short answer: You can't. That is not how async processing works. The result will NEVER be available at the time your method returns. In fact your method returns before the async processing even beings.

As ABakerSmith says in his comment, what you should do is to add a completion handler closure (aka block) as a parameter to the function. That is a block of code that the caller passes in. You write your method so that once the async JSON data is done downloading, it invokes the completion block.

Then in your caller you write your code to pass in the code that you want to execute once the download is complete IN THE COMPLETION BLOCK. You have to structure your program so that it can operate without your data (for example, by displaying an empty table view) and the update itself once the data arrives. You might write your completion block to install the data in the data model for a table view and then call reloadData on the table view.

It's generally safer if you write your async method so it performs the completion block on the main thread.

Answer 3

Here an example how to do asynchronous work in a separate thread and then returning back to the main thread in order to update the UI

    let priority = DISPATCH_QUEUE_PRIORITY_DEFAULT
    dispatch_async(dispatch_get_global_queue(priority, 0)) {

        // do some asynchronous work

        dispatch_async(dispatch_get_main_queue()) {

            // use returned data to update some UI on the main thread
        }
    }