No Swift, como chamar o método com parâmetros no thread principal do GCD?

No meu aplicativo, tenho uma função que cria uma NSRURLSession e envia uma NSURLRequest usando

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

No bloco de conclusão desta tarefa, preciso fazer alguns cálculos que adicionem uma UIImage ao viewcontroller de chamada. Eu tenho uma função chamada

func displayQRCode(receiveAddr, withAmountInBTC:amountBTC)

que faz o cálculo de adição de UIImage. Se eu tentar executar o código de adição de exibição dentro do bloco de conclusão, o Xcode emitirá um erro dizendo que não posso usar o mecanismo de layout enquanto estiver em um processo em segundo plano. Então, eu encontrei algum código no SO que tenta enfileirar um método no thread principal:

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)
})

No entanto, não sei como adicionar os parâmetros "receiveAddr" e "amountBTC" a essa chamada de função. Como eu faria isso, ou alguém pode sugerir uma maneira ideal de adicionar uma chamada de método à fila principal do aplicativo?

As versões modernas do Swift usam DispatchQueue.main.asyncpara despachar para o encadeamento principal:

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

Para despachar depois na fila principal, use:

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

Versões anteriores do Swift usadas:

dispatch_async(dispatch_get_main_queue(), {
  let delegateObj = UIApplication.sharedApplication().delegate as YourAppDelegateClass
  delegateObj.addUIImage("yourstring")
})

Versão Swift 3+ e Swift 4:

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

Swift 3 e Xcode 9.2:

dispatch_async_on_main_queue {
    print("Hello")
}

Swift 2

Usando Trailing Closures, isso se torna:

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

Trailing Closures é o açúcar sintático Swift que permite definir o fechamento fora do escopo do parâmetro da função. Para obter mais informações, consulte Trailing Closures no Swift 2.2 Programming Language Guide.

No caso dispatch_async, a API é func dispatch_async(queue: dispatch_queue_t, _ block: dispatch_block_t)uma vez que dispatch_block_té do tipo alias para () -> Void- Um fechamento que recebe 0 parâmetros e não possui um valor de retorno, e bloco sendo o último parâmetro da função, podemos definir o fechamento no escopo externo de dispatch_async.

Recarregar coleçãoView on Main Thread

DispatchQueue.main.async {
    self.collectionView.reloadData()
}

Aqui está a melhor sintaxe do estilo Swifty / Cocoa (IMO) para obter o mesmo resultado que as outras respostas:

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

Ou você pode pegar a popular biblioteca Async Swift para obter ainda menos código e mais funcionalidades:

Async.main {
    // Your code here
}

A maneira correta de fazer isso é usar dispatch_async no main_queue, como fiz no código a seguir

dispatch_async(dispatch_get_main_queue(), {
    (self.delegate as TBGQRCodeViewController).displayQRCode(receiveAddr, withAmountInBTC:amountBTC)
})

Aqui está uma pequena função global que você pode adicionar para obter uma sintaxe melhor:

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

E uso

dispatch_on_main {
    // Do some UI stuff
}

//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()
})

Não se esqueça de enfraquecer a si mesmo se você estiver usando a si mesma dentro do fechamento.

dispatch_async(dispatch_get_main_queue(),{ [weak self] () -> () in
    if let strongSelf = self {
        self?.doSomething()
    }
})