Como criar fila de expedição no Swift 3

No Swift 2, consegui criar fila com o seguinte código:

let concurrentQueue = dispatch_queue_create("com.swift3.imageQueue", DISPATCH_QUEUE_CONCURRENT)

Mas isso não é compilado no Swift 3.

Qual é a maneira preferida de escrever isso no Swift 3?

Criando uma fila simultânea

let concurrentQueue = DispatchQueue(label: "queuename", attributes: .concurrent)
concurrentQueue.sync {

}  

Crie uma fila serial

let serialQueue = DispatchQueue(label: "queuename")
serialQueue.sync { 

}

Obter fila principal de forma assíncrona

DispatchQueue.main.async {

}

Obter fila principal de forma síncrona

DispatchQueue.main.sync {

}

Para obter um dos threads em segundo plano

DispatchQueue.global(qos: .background).async {

}

Xcode 8.2 beta 2:

Para obter um dos threads em segundo plano

DispatchQueue.global(qos: .default).async {

}

DispatchQueue.global().async {
    // qos' default value is ´DispatchQoS.QoSClass.default`
}

Se você quiser aprender sobre o uso dessas filas, consulte esta resposta

Compila em> = Swift 3 . Este exemplo contém a maior parte da sintaxe que precisamos.

QoS - nova sintaxe de qualidade de serviço

weak self - interromper ciclos de retenção

se o eu não estiver disponível, não faça nada

async global utility queue- para consulta de rede, não espera o resultado, é uma fila simultânea, o bloco (geralmente) não espera quando iniciado. A exceção para uma fila simultânea pode ser que, quando seu limite de tarefas foi atingido anteriormente, a fila se transforma temporariamente em uma fila serial e aguarda até que alguma tarefa anterior nessa fila seja concluída.

async main queue- para tocar na interface do usuário, o bloco não espera o resultado, mas espera pelo slot no início. A fila principal é uma fila serial.

Obviamente, você precisa adicionar alguma verificação de erro a isso ...

DispatchQueue.global(qos: .utility).async { [weak self] () -> Void in

    guard let strongSelf = self else { return }

    strongSelf.flickrPhoto.loadLargeImage { loadedFlickrPhoto, error in

        if error != nil {
            print("error:\(error)")
        } else {
            DispatchQueue.main.async { () -> Void in
                activityIndicator.removeFromSuperview()
                strongSelf.imageView.image = strongSelf.flickrPhoto.largeImage
            }
        }
    }
}

Compilado no XCode 8, Swift 3 https://github.com/rpthomas/Jedisware

 @IBAction func tap(_ sender: AnyObject) {

    let thisEmail = "emailaddress.com"
    let thisPassword = "myPassword" 

    DispatchQueue.global(qos: .background).async {

        // Validate user input

        let result = self.validate(thisEmail, password: thisPassword)

        // Go back to the main thread to update the UI
        DispatchQueue.main.async {
            if !result
            {
                self.displayFailureAlert()
            }

        }
    }

}

Como a pergunta do OP já foi respondida acima, só quero adicionar algumas considerações de velocidade:

Faz muita diferença qual classe de prioridade você atribui à sua função assíncrona em DispatchQueue.global .

Não recomendo executar tarefas com a prioridade do encadeamento .background, especialmente no iPhone X, onde a tarefa parece estar alocada nos núcleos de baixo consumo de energia.

Aqui estão alguns dados reais de uma função computacionalmente intensiva que lê um arquivo XML (com buffer) e executa a interpolação de dados:

Nome do dispositivo / .background / .utility / .default / .userInitiated / .userInteractive

1. iPhone X: 18.7s / 6.3s / 1.8s / 1.8s / 1.8s
2. iPhone 7: 4.6s / 3.1s / 3.0s / 2.8s / 2.6s
3. iPhone 5s: 7.3s / 6.1s / 4.0s / 4.0s / 3.8s

Observe que o conjunto de dados não é o mesmo para todos os dispositivos. É o maior do iPhone X e o menor do iPhone 5s.

Fiz isso e isso é especialmente importante se você deseja atualizar sua interface do usuário para mostrar novos dados sem que o usuário perceba, como no UITableView ou no UIPickerView.

    DispatchQueue.main.async
 {
   /*Write your thread code here*/
 }

 DispatchQueue.main.async {
          self.collectionView?.reloadData() // Depends if you were populating a collection view or table view
    }


OperationQueue.main.addOperation {
    self.lblGenre.text = self.movGenre
}

// use a Fila de operação se precisar preencher os objetos (rótulos, visualização de imagem, visualização de texto) no seu controlador de exibição

   let concurrentQueue = dispatch_queue_create("com.swift3.imageQueue", DISPATCH_QUEUE_CONCURRENT) //Swift 2 version

   let concurrentQueue = DispatchQueue(label:"com.swift3.imageQueue", attributes: .concurrent) //Swift 3 version

Eu refiz seu código no Xcode 8, Swift 3 e as alterações são marcadas em contraste com a sua versão do Swift 2.

Swift 3

Se você deseja encerrar o código rapidamente, deseja alterar o storyboard. Qualquer tipo de alteração pertence à visualização do aplicativo.

mas você deseja usar o método de despacho, seu aplicativo não falhará

método assíncrono

DispatchQueue.main.async 
{
 //Write code here                                   

}

método de sincronização

DispatchQueue.main.sync 
{
     //Write code here                                  

}

DispatchQueue.main.async(execute: {

// write code

})

Fila serial:

let serial = DispatchQueue(label: "Queuename")

serial.sync { 

 //Code Here

}

Fila simultânea:

 let concurrent = DispatchQueue(label: "Queuename", attributes: .concurrent)

concurrent.sync {

 //Code Here
}

Para Swift 3

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

 let newQueue = DispatchQueue(label: "newname")
 newQueue.sync { 

 // your code

 }

Atualização para o swift 5

Fila serial

let serialQueue = DispatchQueue.init(label: "serialQueue")
serialQueue.async {
    // code to execute
}

Fila simultânea

let concurrentQueue = DispatchQueue.init(label: "concurrentQueue", qos: .background, attributes: .concurrent, autoreleaseFrequency: .inherit, target: nil)

concurrentQueue.async {
// code to execute
}

Da documentação da Apple :

Parâmetros

rótulo

Um rótulo de cadeia para anexar à fila para identificá-lo exclusivamente em ferramentas de depuração, como Instrumentos, amostra, stackshots e relatórios de falha. Como aplicativos, bibliotecas e estruturas podem criar suas próprias filas de despacho, um estilo de nomeação de DNS reverso (com.example.myqueue) é recomendado. Este parâmetro é opcional e pode ser NULL.

qos

O nível de qualidade de serviço a ser associado à fila. Este valor determina a prioridade na qual o sistema agenda tarefas para execução. Para obter uma lista dos valores possíveis, consulte DispatchQoS.QoSClass.

atributos

Os atributos a serem associados à fila. Inclua o atributo simultâneo para criar uma fila de expedição que execute tarefas simultaneamente. Se você omitir esse atributo, a fila de expedição executará tarefas em série.

autoreleaseFrequency

A frequência com a qual liberar automaticamente objetos criados pelos blocos agendados pela fila. Para obter uma lista de valores possíveis, consulte DispatchQueue.AutoreleaseFrequency .

alvo

A fila de destino na qual executar blocos. Especifique DISPATCH_TARGET_QUEUE_DEFAULT se desejar que o sistema forneça uma fila apropriada para o objeto atual.

agora é simplesmente:

let serialQueue = DispatchQueue(label: "my serial queue")

o padrão é serial, para ser simultâneo, use o argumento de atributos opcionais .concurrent

DispatchQueue.main.async(execute: {
   // code
})

Você pode criar fila de expedição usando esse código no swift 3.0

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

   /* or */

let delayTime = DispatchTime.now() + Double(Int64(0.5 * Double(NSEC_PER_SEC))) / Double(NSEC_PER_SEC)                   
DispatchQueue.main.asyncAfter(deadline: delayTime)
{
  /*Write your code here*/
}