199

In my app I have a function that makes an NSRURLSession and sends out an NSURLRequest using

sesh.dataTaskWithRequest(req, completionHandler: {(data, response, error)

In the completion block for this task, I need to do some computation that adds a UIImage to the calling viewcontroller. I have a func called

func displayQRCode(receiveAddr, withAmountInBTC:amountBTC)

that does the UIImage-adding computation. If I try to run the view-adding code inside of the completion block, Xcode throws an error saying that I can't use the layout engine while in a background process. So I found some code on SO that tries to queue a method on the main thread:

let time = dispatch_time(DISPATCH_TIME_NOW, Int64(0.0 * Double(NSEC_PER_MSEC)))

dispatch_after(time, dispatch_get_main_queue(), {
    let returned = UIApplication.sharedApplication().sendAction("displayQRCode:", to: self.delegate, from: self, forEvent: nil)
})

However, I don't know how to add the parameters "receiveAddr" and "amountBTC" to this function call. How would I do this, or can someone suggest an optimal way for adding a method call to the application's main queue?

pkamb
  • 26,648
  • 20
  • 124
  • 157
almel
  • 5,614
  • 10
  • 36
  • 52

9 Answers9

511

Modern versions of Swift use DispatchQueue.main.async to dispatch to the main thread:

DispatchQueue.main.async { 
  // your code here
}

To dispatch after on the main queue, use:

DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
  // your code here
}

Older versions of Swift used:

dispatch_async(dispatch_get_main_queue(), {
  let delegateObj = UIApplication.sharedApplication().delegate as YourAppDelegateClass
  delegateObj.addUIImage("yourstring")
})
pkamb
  • 26,648
  • 20
  • 124
  • 157
codester
  • 34,623
  • 10
  • 72
  • 70
  • While you are correct that your suggestion works, I think my answer is slightly better because it does not make a call to UIApplication.sharedApplication, which is unusual and might throw off other readers of my code. The scope of my answer is constrained to the objects of importance, while yours brings in ancillary objects that require me to read more docs to learn exactly what I'm doing. And I've edited my original question to contain the correct function call. I had thought the displayQRCode wasn't specific enough but with our comments now it is. Thanks for pointing that out. – almel Jul 28 '14 at 03:27
85

Swift 3+ & Swift 4 version:

DispatchQueue.main.async {
    print("Hello")
}

Swift 3 and Xcode 9.2:

dispatch_async_on_main_queue {
    print("Hello")
}
pkamb
  • 26,648
  • 20
  • 124
  • 157
DazChong
  • 3,306
  • 25
  • 23
15

Swift 2

Using Trailing Closures this becomes:

dispatch_async(dispatch_get_main_queue()) {
    self.tableView.reloadData()
}

Trailing Closures is Swift syntactic sugar that enables defining the closure outside of the function parameter scope. For more information see Trailing Closures in Swift 2.2 Programming Language Guide.

In dispatch_async case the API is func dispatch_async(queue: dispatch_queue_t, _ block: dispatch_block_t) since dispatch_block_t is type alias for () -> Void - A closure that receives 0 parameters and does not have a return value, and block being the last parameter of the function we can define the closure in the outer scope of dispatch_async.

Maxim Veksler
  • 25,736
  • 34
  • 119
  • 148
8

Reload collectionView on Main Thread

DispatchQueue.main.async {
    self.collectionView.reloadData()
}
pkamb
  • 26,648
  • 20
  • 124
  • 157
Sanjay Mali
  • 397
  • 4
  • 12
7

Here's the nicer (IMO) Swifty/Cocoa style syntax to achieve the same result as the other answers:

NSOperationQueue.mainQueue().addOperationWithBlock({
    // Your code here
})

Or you could grab the popular Async Swift library for even less code and more functionality:

Async.main {
    // Your code here
}
pejalo
  • 762
  • 7
  • 21
3

The proper way to do this is to use dispatch_async in the main_queue, as I did in the following code

dispatch_async(dispatch_get_main_queue(), {
    (self.delegate as TBGQRCodeViewController).displayQRCode(receiveAddr, withAmountInBTC:amountBTC)
})
pkamb
  • 26,648
  • 20
  • 124
  • 157
almel
  • 5,614
  • 10
  • 36
  • 52
2

Don't forget to weakify self if you are using self inside of the closure.

dispatch_async(dispatch_get_main_queue(),{ [weak self] () -> () in
    if let strongSelf = self {
        self?.doSomething()
    }
})
pkamb
  • 26,648
  • 20
  • 124
  • 157
villy393
  • 2,841
  • 17
  • 26
  • 1
    Could you please explain why we should be doing this ? – Jackspicer Nov 29 '16 at 10:22
  • It's because it can create memory cycles - i.e. I have a strong reference to something and it has a strong reference to me. Meaning neither of us can leave the memory heap. – jackofallcode Mar 10 '17 at 12:01
2

Here's a nice little global function you can add for a nicer syntax:

func dispatch_on_main(block: dispatch_block_t) {
    dispatch_async(dispatch_get_main_queue(), block)
}

And usage

dispatch_on_main {
    // Do some UI stuff
}
2
//Perform some task and update UI immediately.
DispatchQueue.global(qos: .userInitiated).async {  
    // Call your function here
    DispatchQueue.main.async {  
        // Update UI
        self.tableView.reloadData()  
    }
}

//To call or execute function after some time
DispatchQueue.main.asyncAfter(deadline: .now() + 5.0) {
    //Here call your function
}

//If you want to do changes in UI use this
DispatchQueue.main.async(execute: {
    //Update UI
    self.tableView.reloadData()
})
iOS
  • 11,881
  • 4
  • 71
  • 92