Como usar o threading no swift?

dispatchOnMainThread:^{

    NSLog(@"Block Executed On %s", dispatch_queue_get_label(dispatch_get_current_queue()));

}];

Swift 3.0+

Muito foi modernizado no Swift 3.0. A execução de algo no segmento de plano de fundo se parece com o seguinte:

DispatchQueue.global(qos: .background).async {
    print("This is run on the background queue")

    DispatchQueue.main.async {
        print("This is run on the main queue, after the previous code in outer block")
    }
}

Swift 1.2 a 2.3

let qualityOfServiceClass = QOS_CLASS_BACKGROUND
let backgroundQueue = dispatch_get_global_queue(qualityOfServiceClass, 0)
dispatch_async(backgroundQueue, {
    print("This is run on the background queue")

    dispatch_async(dispatch_get_main_queue(), { () -> Void in
        print("This is run on the main queue, after the previous code in outer block")
    })
})

Pre Swift 1.2 - Problema conhecido

A partir do Swift 1.1, a Apple não suportava a sintaxe acima sem algumas modificações. Passar QOS_CLASS_BACKGROUNDrealmente não funcionou; em vez disso, use Int(QOS_CLASS_BACKGROUND.value).

Para obter mais informações, consulte a documentação da Apple.

A melhor prática é definir uma função reutilizável que possa ser acessada várias vezes.

FUNÇÃO REUTILIZÁVEL:

por exemplo, em algum lugar como AppDelegate.swift como uma função global.

func backgroundThread(_ delay: Double = 0.0, background: (() -> Void)? = nil, completion: (() -> Void)? = nil) {
    dispatch_async(dispatch_get_global_queue(Int(QOS_CLASS_USER_INITIATED.value), 0)) {
        background?()

        let popTime = dispatch_time(DISPATCH_TIME_NOW, Int64(delay * Double(NSEC_PER_SEC)))
        dispatch_after(popTime, dispatch_get_main_queue()) {
            completion?()
        }
    }
}

Nota: em Swift 2.0, substituir QOS_CLASS_USER_INITIATED.value acima com QOS_CLASS_USER_INITIATED.rawValue vez

USO:

A. Para executar um processo em segundo plano com um atraso de 3 segundos:

    backgroundThread(3.0, background: {
            // Your background function here
    })

B. Para executar um processo em segundo plano, execute uma conclusão em primeiro plano:

    backgroundThread(background: {
            // Your function here to run in the background
    },
    completion: {
            // A function to run in the foreground when the background thread is complete
    })

C. Atraso em 3 segundos - observe o uso do parâmetro de conclusão sem o parâmetro de segundo plano:

    backgroundThread(3.0, completion: {
            // Your delayed function here to be run in the foreground
    })

A resposta de Dan Beaulieu no swift5 (também trabalhando desde o swift 3.0.1).

Swift 5.0.1

extension DispatchQueue {

    static func background(delay: Double = 0.0, background: (()->Void)? = nil, completion: (() -> Void)? = nil) {
        DispatchQueue.global(qos: .background).async {
            background?()
            if let completion = completion {
                DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: {
                    completion()
                })
            }
        }
    }

}

Uso

DispatchQueue.background(delay: 3.0, background: {
    // do something in background
}, completion: {
    // when background job finishes, wait 3 seconds and do something in main thread
})

DispatchQueue.background(background: {
    // do something in background
}, completion:{
    // when background job finished, do something in main thread
})

DispatchQueue.background(delay: 3.0, completion:{
    // do something in main thread after 3 seconds
})

Versão Swift 3

O Swift 3 utiliza nova DispatchQueueclasse para gerenciar filas e threads. Para executar algo no thread de segundo plano, você usaria:

let backgroundQueue = DispatchQueue(label: "com.app.queue", qos: .background)
backgroundQueue.async {
    print("Run on background thread")
}

Ou se você quiser algo em duas linhas de código:

DispatchQueue.global(qos: .background).async {
    print("Run on background thread")

    DispatchQueue.main.async {
        print("We finished that.")
        // only back on the main thread, may you access UI:
        label.text = "Done."
    }
}

Você também pode obter informações detalhadas sobre o GDC no Swift 3 neste tutorial .

Do tutorial de Jameson Quave

Swift 2

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), {
    //All stuff here
})

No Swift 4.2 e no Xcode 10.1

Temos três tipos de filas:

1. Fila principal: a fila principal é uma fila serial criada pelo sistema e associada ao encadeamento principal do aplicativo.

2. Fila Global: A fila global é uma fila simultânea que podemos solicitar com relação à prioridade das tarefas.

3. Filas personalizadas: podem ser criadas pelo usuário. As filas simultâneas personalizadas sempre são mapeadas para uma das filas globais, especificando uma propriedade de Qualidade de serviço (QoS).

DispatchQueue.main//Main thread
DispatchQueue.global(qos: .userInitiated)// High Priority
DispatchQueue.global(qos: .userInteractive)//High Priority (Little Higher than userInitiated)
DispatchQueue.global(qos: .background)//Lowest Priority
DispatchQueue.global(qos: .default)//Normal Priority (after High but before Low)
DispatchQueue.global(qos: .utility)//Low Priority
DispatchQueue.global(qos: .unspecified)//Absence of Quality

Todas essas filas podem ser executadas de duas maneiras

1. Execução síncrona

2. Execução assíncrona

DispatchQueue.global(qos: .background).async {
    // do your job here
    DispatchQueue.main.async {
        // update ui here
    }
}

//Perform some task and update UI immediately.
DispatchQueue.global(qos: .userInitiated).async {  
    // Perform task
    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()
})

No AppCoda: https://www.appcoda.com/grand-central-dispatch/

//This will print synchronously means, it will print 1-9 & 100-109
func simpleQueues() {
    let queue = DispatchQueue(label: "com.appcoda.myqueue")

    queue.sync {
        for i in 0..<10 {
            print("🔴", i)
        }
    }

    for i in 100..<110 {
        print("Ⓜ️", i)
    }
}

//This will print asynchronously 
func simpleQueues() {
    let queue = DispatchQueue(label: "com.appcoda.myqueue")

    queue.async {
        for i in 0..<10 {
            print("🔴", i)
        }
    }

    for i in 100..<110 {
        print("Ⓜ️", i)
    }
}

Swift 4.x

Coloque isso em algum arquivo:

func background(work: @escaping () -> ()) {
    DispatchQueue.global(qos: .userInitiated).async {
        work()
    }
}

func main(work: @escaping () -> ()) {
    DispatchQueue.main.async {
        work()
    }
}

e depois chame onde precisar:

background {
     //background job
     main {
       //update UI (or what you need to do in main thread)
     }
}

Você precisa separar as alterações que deseja executar em segundo plano das atualizações que deseja executar na interface do usuário:

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)) {
    // do your task

    dispatch_async(dispatch_get_main_queue()) {
        // update some UI
    }
}

Boas respostas, no entanto, de qualquer maneira, quero compartilhar minha solução Orientada a Objetos Atualizada para o Swift 5 .

confira: AsyncTask

Inspirado conceitualmente pelo AsyncTask do Android, escrevi minha própria aula no Swift

O AsyncTask permite o uso adequado e fácil do thread da interface do usuário. Essa classe permite executar operações em segundo plano e publicar resultados no thread da interface do usuário.

Aqui estão alguns exemplos de uso

Exemplo 1 -

AsyncTask(backgroundTask: {(p:String)->Void in//set BGParam to String and BGResult to Void
        print(p);//print the value in background thread
    }).execute("Hello async");//execute with value 'Hello async'

Exemplo 2 -

let task2=AsyncTask(beforeTask: {
           print("pre execution");//print 'pre execution' before backgroundTask
        },backgroundTask:{(p:Int)->String in//set BGParam to Int & BGResult to String
            if p>0{//check if execution value is bigger than zero
               return "positive"//pass String "poitive" to afterTask
            }
            return "negative";//otherwise pass String "negative"
        }, afterTask: {(p:String) in
            print(p);//print background task result
    });
    task2.execute(1);//execute with value 1

Possui 2 tipos genéricos:

• BGParam - o tipo do parâmetro enviado para a tarefa após a execução.

• BGResult - o tipo do resultado da computação em segundo plano.

  Ao criar um AsyncTask, você pode esses tipos para o que for necessário para passar e sair da tarefa em segundo plano, mas se você não precisar desses tipos, poderá marcá-lo como não utilizado, apenas configurando-o para: Voidou com sintaxe mais curta:()

Quando uma tarefa assíncrona é executada, ela realiza três etapas:

1. beforeTask:()->Void chamado no thread da interface do usuário imediatamente antes da tarefa ser executada.
2. backgroundTask: (param:BGParam)->BGResult chamado no encadeamento em segundo plano imediatamente após
3. afterTask:(param:BGResult)->Void chamado no encadeamento da interface do usuário com resultado da tarefa em segundo plano

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

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 baixa 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.

Swift 5

Para facilitar, crie um arquivo "DispatchQueue + Extensions.swift" com este conteúdo:

import Foundation

typealias Dispatch = DispatchQueue

extension Dispatch {

    static func background(_ task: @escaping () -> ()) {
        Dispatch.global(qos: .background).async {
            task()
        }
    }

    static func main(_ task: @escaping () -> ()) {
        Dispatch.main.async {
            task()
        }
    }
}

Uso:

Dispatch.background {
    // do stuff

    Dispatch.main { 
        // update UI
    }
}

O Grand Central Dispatch é usado para lidar com multitarefa em nossos aplicativos para iOS.

Você pode usar este código

// Using time interval

DispatchQueue.main.asyncAfter(deadline: DispatchTime.now()+1) {
    print("Hello World")
}

// Background thread
queue.sync {
     for i in 0..<10 {
          print("Hello", i)
     }
}

// Main thread
for i in 20..<30 {
     print("Hello", i)
}

Mais informações usam este link: https://www.programminghub.us/2018/07/integrate-dispatcher-in-swift.html

Função multiuso para rosca

public enum QueueType {
        case Main
        case Background
        case LowPriority
        case HighPriority

        var queue: DispatchQueue {
            switch self {
            case .Main:
                return DispatchQueue.main
            case .Background:
                return DispatchQueue(label: "com.app.queue",
                                     qos: .background,
                                     target: nil)
            case .LowPriority:
                return DispatchQueue.global(qos: .userInitiated)
            case .HighPriority:
                return DispatchQueue.global(qos: .userInitiated)
            }
        }
    }

    func performOn(_ queueType: QueueType, closure: @escaping () -> Void) {
        queueType.queue.async(execute: closure)
    }

Use-o como:

performOn(.Background) {
    //Code
}

Gosto muito da resposta de Dan Beaulieu, mas ela não funciona com o Swift 2.2 e acho que podemos evitar aqueles desagradáveis ​​arranjos forçados!

func backgroundThread(delay: Double = 0.0, background: (() -> Void)? = nil, completion: (() -> Void)? = nil) {

    dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0)) {

        background?()

        if let completion = completion{
            let popTime = dispatch_time(DISPATCH_TIME_NOW, Int64(delay * Double(NSEC_PER_SEC)))
            dispatch_after(popTime, dispatch_get_main_queue()) {
                completion()
            }
        }
    }
}

dispatch_async(dispatch_get_global_queue(QOS_CLASS_BACKGROUND, 0), {
    // Conversion into base64 string
    self.uploadImageString =  uploadPhotoDataJPEG.base64EncodedStringWithOptions(NSDataBase64EncodingOptions.EncodingEndLineWithCarriageReturn)
})

no Swift 4.2, isso funciona.

import Foundation

class myThread: Thread
{
    override func main() {
        while(true) {
            print("Running in the Thread");
            Thread.sleep(forTimeInterval: 4);
        }
    }
}

let t = myThread();
t.start();

while(true) {
    print("Main Loop");
    sleep(5);
}