Как использовать фоновый поток в Swift?

Question

Как использовать фоновый поток в Swift?

Как использовать потоки в Swift?

dispatchOnMainThread:^{

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

}];

425

ios swift multithreading dispatch-queue

Источник

user3376425 05 июн '14 в 09:16

17 ответов

Другие вопросы по тегам ios swift multithreading dispatch-queue

user1572847 31 июл '14 в 23:15 2014-07-31 23:15 · Answer 1 · 2014-07-31 23:15

Swift 3.0+

Многое было модернизировано в Swift 3.0. Запуск чего-либо в фоновом потоке выглядит следующим образом:

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

Свифт с 1.2 по 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 - Известная проблема

Начиная с Swift 1.1 Apple не поддерживала вышеуказанный синтаксис без некоторых модификаций. Переходя QOS_CLASS_BACKGROUND на самом деле не работает, вместо этого используйте Int(QOS_CLASS_BACKGROUND.value),

Для получения дополнительной информации см. Документацию Apple.

user1679768 06 дек '16 в 14:25 2016-12-06 14:25 · Answer 2 · 2016-12-06 14:25

Дэн Болье ответ в swift3.

Swift 3.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()
                })
            }
        }
    }

}

использование

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

user4516270 15 июн '15 в 09:13 2015-06-15 09:13 · Answer 3 · 2015-06-15 09:13

Рекомендуется определить функцию многократного использования, к которой можно обращаться несколько раз.

ВОЗМОЖНАЯ ФУНКЦИЯ:

например, где-то вроде AppDelegate.swift в качестве глобальной функции.

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)) {
        if(background != nil){ background!(); }

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

Примечание: в Swift 2.0 замените QOS_CLASS_USER_INITIATED.value выше на QOS_CLASS_USER_INITIATED.rawValue вместо

ИСПОЛЬЗОВАНИЕ:

A. Чтобы запустить процесс в фоновом режиме с задержкой в 3 секунды:

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

Б. Чтобы запустить процесс в фоновом режиме, затем выполнить завершение на переднем плане:

    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. Для задержки на 3 секунды - обратите внимание на использование параметра завершения без параметра фона:

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

user8090893 16 авг '18 в 12:51 2018-08-16 12:51 · Answer 4 · 2018-08-16 12:51

В Swift 4.2 и Xcode 10

//To call 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: {

})

58

Источник

user8090893 16 авг '18 в 12:51

user4590961 16 июн '16 в 15:13 2016-06-16 15:13 · Answer 5 · 2016-06-16 15:13

Версия Swift 3

Swift 3 использует новый DispatchQueue класс для управления очередями и потоками. Для запуска чего-либо в фоновом потоке вы должны использовать:

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

Или, если вы хотите что-то в две строки кода:

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."
    }
}

В этом руководстве вы также можете получить подробную информацию о GDC в Swift 3.

user1560760 05 июн '14 в 09:23 2014-06-05 09:23 · Answer 6 · 2014-06-05 09:23

Из учебника Jameson Quave

Swift 2

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

35

Источник

user1560760 05 июн '14 в 09:23

user5120292 01 апр '20 в 15:46 2020-04-01 15:46 · Answer 7 · 2020-04-01 15:46

Swift 5

Чтобы упростить задачу, создайте файл DispatchQueue+Extensions.swift со следующим содержимым:

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

Применение:

Dispatch.background {
    // do stuff

    Dispatch.main { 
        // update UI
    }
}

user4981177 20 авг '18 в 09:13 2018-08-20 09:13 · Answer 8 · 2018-08-20 09:13

Swift 4.1

Поместите это в какой-нибудь файл:

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

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

а затем позвоните туда, где вам нужно:

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

28

Источник

user4981177 20 авг '18 в 09:13

user3614616 07 июл '15 в 08:38 2015-07-07 08:38 · Answer 9 · 2015-07-07 08:38

Вы должны отделить изменения, которые вы хотите запустить в фоновом режиме, от обновлений, которые вы хотите запустить в пользовательском интерфейсе:

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

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

22

Источник

user3614616 07 июл '15 в 08:38

user3219049 04 фев '16 в 18:52 2016-02-04 18:52 · Answer 10 · 2016-02-04 18:52

Хорошие ответы, но в любом случае я хочу поделиться своим объектно-ориентированным решением, обновленным для swift 3.

пожалуйста, проверьте это: AsyncTask

Концептуально вдохновленный Android AsyncTask, я написал свой собственный класс в Swift

AsyncTask позволяет правильно и легко использовать поток пользовательского интерфейса. Этот класс позволяет выполнять фоновые операции и публиковать результаты в потоке пользовательского интерфейса.

Вот несколько примеров использования

Пример 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'

Пример 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

Имеет 2 общих типа:

BGParam - тип параметра, отправляемого заданию при выполнении.
BGResult - тип результата фонового вычисления.
Когда вы создаете AsyncTask, вы можете добавить эти типы к тому, что вам нужно передать в фоновую задачу и из нее, но если вам не нужны эти типы, вы можете пометить его как неиспользуемый, просто установив его: Void или с более коротким синтаксисом: ()

Когда асинхронная задача выполняется, она проходит 3 этапа:

beforeTask:()->Void вызывается в потоке пользовательского интерфейса непосредственно перед выполнением задачи.
backgroundTask: (param:BGParam)->BGResult вызывается в фоновом потоке сразу после
afterTask:(param:BGResult)->Void вызывается в потоке пользовательского интерфейса с результатом из фоновой задачи

user102901 16 май '18 в 12:37 2018-05-16 12:37 · Answer 11 · 2018-05-16 12:37

Поскольку на вопрос ОП уже был дан ответ, я просто хочу добавить некоторые соображения по поводу скорости:

Я не рекомендую запускать задачи с приоритетом потока .background, особенно на iPhone X, где задача, кажется, размещена на ядрах с низким энергопотреблением.

Вот некоторые реальные данные из вычислительно интенсивной функции, которая читает из файла XML (с буферизацией) и выполняет интерполяцию данных:

Имя устройства / .background / .utility / .default / .userInitiated / .userInteractive

iPhone X: 18,7 с / 6,3 с / 1,8 с / 1,8 с / 1,8 с
iPhone 7: 4,6 с / 3,1 с / 3,0 с / 2,8 с / 2,6 с
iPhone 5s: 7,3 с / 6,1 с / 4,0 с / 4,0 с / 3,8 с

Обратите внимание, что набор данных не одинаков для всех устройств. Это самый большой на iPhone X и самый маленький на iPhone 5s.

user10089682 19 апр '19 в 15:34 2019-04-19 15:34 · Answer 12 · 2019-04-19 15:34

Многоцелевая функция для потока

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

Используйте это как:

performOn(.Background) {
    //Code
}

user6134275 02 июл '18 в 14:15 2018-07-02 14:15 · Answer 13 · 2018-07-02 14:15

Grand Central Dispatch используется для обработки многозадачности в наших приложениях для iOS.

Вы можете использовать этот код

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

Дополнительную информацию можно получить по этой ссылке: https://www.programminghub.us/2018/07/integrate-dispatcher-in-swift.html

user5443134 25 фев '22 в 14:52 2022-02-25 14:52 · Answer 14 · 2022-02-25 14:52

Есть ли недостаток (когда после этого нужно запустить экран переднего плана) в приведенном ниже коде?

      import Foundation
import UIKit

class TestTimeDelay {

    static var connected:Bool = false
    
    static var counter:Int = 0

    static func showAfterDelayControl(uiViewController:UIViewController) {
        NSLog("TestTimeDelay", "showAfterDelayControl")
    }
    
    static func tryReconnect() -> Bool {
        counter += 1
        NSLog("TestTimeDelay", "Counter:\(counter)")
        return counter > 4
    }

    static func waitOnConnectWithDelay(milliseconds:Int, uiViewController: UIViewController) {
        
        DispatchQueue.global(qos: .background).async {
            DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + DispatchTimeInterval.milliseconds(milliseconds), execute: {
                waitOnConnect(uiViewController: uiViewController)
            })
        }
    }

    static func waitOnConnect(uiViewController:UIViewController) {

        connected = tryReconnect()
        if connected {
            showAfterDelayControl(uiViewController: uiViewController)
        }
        else {
            waitOnConnectWithDelay(milliseconds: 200, uiViewController:uiViewController)
        }
     }
}

user183102 03 май '16 в 13:55 2016-05-03 13:55 · Answer 15 · 2016-05-03 13:55

Мне очень нравится ответ Дэна Болье, но он не работает со Swift 2.2, и я думаю, что мы можем избежать этих отвратительных принудительных развертываний!

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

user5259891 03 ноя '15 в 07:39 2015-11-03 07:39 · Answer 16 · 2015-11-03 07:39

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

0

Источник

user5259891 03 ноя '15 в 07:39

user662884 22 сен '18 в 12:52 2018-09-22 12:52 · Answer 17 · 2018-09-22 12:52

В Swift 4.2 это работает.

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

-1

Источник

user662884 22 сен '18 в 12:52