Jak mogę dispatch_sync, dispatch_async, dispatch_after itp. W Swift 3, Swift 4 i nowszych wersjach?

Mam dużo kodu w projektach Swift 2.x (lub nawet 1.x), które wyglądają tak:

// Move to a background thread to do some long running work
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)) {
    let image = self.loadOrGenerateAnImage()
    // Bounce back to the main thread to update the UI
    dispatch_async(dispatch_get_main_queue()) {
        self.imageView.image = image
    }
}

Lub takie rzeczy, aby opóźnić wykonanie:

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, Int64(0.5 * Double(NSEC_PER_SEC))), dispatch_get_main_queue()) {
    print("test")
}

Lub wszelkie inne zastosowania API Grand Central Dispatch ...

Teraz, gdy otworzyłem projekt w Xcode 8 (beta) dla Swift 3, otrzymuję różnego rodzaju błędy. Niektóre z nich oferują naprawienie mojego kodu, ale nie wszystkie poprawki generują działający kod. Co mam z tym zrobić?

Od samego początku Swift zapewniał pewne udogodnienia, dzięki którym ObjC i C były bardziej Swifty, dodając więcej z każdą wersją. Teraz, w Swift 3, nowa funkcja „importuj jako element członkowski” pozwala frameworkom z określonymi stylami C API - gdzie masz typ danych, który działa trochę jak klasa i kilka globalnych funkcji do pracy z nim - działają bardziej jak natywne interfejsy API Swift. Typy danych są importowane jako klasy Swift, powiązane z nimi funkcje globalne są importowane jako metody i właściwości tych klas, a niektóre powiązane rzeczy, takie jak zestawy stałych, mogą w razie potrzeby stać się podtypami.

W Xcode 8 / Swift 3 beta, Apple zastosowało tę funkcję (wraz z kilkoma innymi), aby uczynić framework Dispatch znacznie bardziej Swifty. (A także Core Graphics .) Jeśli śledzisz wysiłki Swift open source, to nie jest nowość , ale teraz jest to pierwsza część Xcode.

Pierwszym krokiem na przeniesienie dowolnego projektu Swift 3 powinno być, aby otworzyć go w Xcode 8 i wybierz Edycja> Przekształć> do aktualnych Swift Składnia ... w menu. Spowoduje to zastosowanie (za Twoją weryfikacją i zatwierdzeniem) wszystkie zmiany potrzebne jednocześnie dla wszystkich interfejsów API o zmienionych nazwach i innych zmian. (Często na wiersz kodu wpływa więcej niż jedna z tych zmian naraz, więc reagowanie na naprawę błędu może nie obsługiwać wszystkiego prawidłowo.)

W rezultacie typowy wzorzec odbijania pracy w tło iz powrotem wygląda teraz następująco:

// Move to a background thread to do some long running work
DispatchQueue.global(qos: .userInitiated).async {
    let image = self.loadOrGenerateAnImage()
    // Bounce back to the main thread to update the UI
    DispatchQueue.main.async {
        self.imageView.image = image
    }
}

Zauważ, że używamy .userInitiatedzamiast jednej ze starych DISPATCH_QUEUE_PRIORITYstałych. Specyfikatory Quality of Service (QoS) zostały wprowadzone w OS X 10.10 / iOS 8.0, zapewniając systemowi bardziej przejrzysty sposób nadawania priorytetów pracy i wycofując stare specyfikatory priorytetów. Szczegółowe informacje można znaleźć w dokumentacji firmy Apple dotyczącej pracy w tle i efektywności energetycznej .

Nawiasem mówiąc, jeśli utrzymujesz własne kolejki w celu zorganizowania pracy, sposób ich uzyskania wygląda teraz następująco (zwróć uwagę, że DispatchQueueAttributesto jest OptionSet, więc używasz literałów w stylu kolekcji do łączenia opcji):

class Foo { 
    let queue = DispatchQueue(label: "com.example.my-serial-queue",
                           attributes: [.serial, .qosUtility])
    func doStuff() {
        queue.async {
            print("Hello World")
        }
    }
}

Używasz dispatch_afterdo późniejszej pracy? Jest to metoda również w przypadku kolejek i wymaga a DispatchTime, która ma operatory dla różnych typów liczbowych, więc możesz po prostu dodać całe lub ułamkowe sekundy:

DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { // in half a second...
    print("Are we there yet?")
}

Możesz poruszać się po nowym interfejsie API Dispatch, otwierając jego interfejs w Xcode 8 - użyj opcji Otwórz szybko, aby znaleźć moduł Dispatch, lub umieść symbol (taki jak DispatchQueue) w swoim projekcie / placu zabaw Swift i kliknij go za pomocą polecenia, a następnie obejrzyj moduł stamtąd. ( Interfejs API Swift Dispatch można znaleźć w nowej witrynie Apple Reference API i przeglądarce dokumentów w formacie Xcode, ale wygląda na to, że treść dokumentu z wersji C jeszcze się do niego nie przeniesiono).

Więcej wskazówek znajdziesz w Przewodniku po migracji .

W Xcode 8 beta 4 nie działa ...

Posługiwać się:

DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
    print("Are we there yet?")
}

dla asynchronii na dwa sposoby:

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

DispatchQueue.main.async( execute: {
    print("Async2")
})

Ten jest dobrym przykładem na Swift 4temat async:

DispatchQueue.global(qos: .background).async {
    // Background Thread
    DispatchQueue.main.async {
        // Run UI Updates or call completion block
    }
}

w Xcode 8 użyj:

DispatchQueue.global(qos: .userInitiated).async { }

Swift 5.2, 4 i nowsze

Kolejki główne i kolejki w tle

let main = DispatchQueue.main
let background = DispatchQueue.global()
let helper = DispatchQueue(label: "another_thread") 

Praca z wątkami asynchronicznymi i synchronizującymi !

 background.async { //async tasks here } 
 background.sync { //sync tasks here } 

Wątki asynchroniczne będą działać razem z wątkiem głównym.

Wątki synchronizacji będą blokować główny wątek podczas wykonywania.

Swift 4.1 i 5. W naszym kodzie używamy kolejek w wielu miejscach. Stworzyłem więc klasę Threads ze wszystkimi kolejkami. Jeśli nie chcesz używać klasy Threads, możesz skopiować żądany kod kolejki z metod klas.

class Threads {

  static let concurrentQueue = DispatchQueue(label: "AppNameConcurrentQueue", attributes: .concurrent)
  static let serialQueue = DispatchQueue(label: "AppNameSerialQueue")

  // Main Queue
  class func performTaskInMainQueue(task: @escaping ()->()) {
    DispatchQueue.main.async {
      task()
    }
  }

  // Background Queue
  class func performTaskInBackground(task:@escaping () throws -> ()) {
    DispatchQueue.global(qos: .background).async {
      do {
        try task()
      } catch let error as NSError {
        print("error in background thread:\(error.localizedDescription)")
      }
    }
  }

  // Concurrent Queue
  class func perfromTaskInConcurrentQueue(task:@escaping () throws -> ()) {
    concurrentQueue.async {
      do {
        try task()
      } catch let error as NSError {
        print("error in Concurrent Queue:\(error.localizedDescription)")
      }
    }
  }

  // Serial Queue
  class func perfromTaskInSerialQueue(task:@escaping () throws -> ()) {
    serialQueue.async {
      do {
        try task()
      } catch let error as NSError {
        print("error in Serial Queue:\(error.localizedDescription)")
      }
    }
  }

  // Perform task afterDelay
  class func performTaskAfterDealy(_ timeInteval: TimeInterval, _ task:@escaping () -> ()) {
    DispatchQueue.main.asyncAfter(deadline: (.now() + timeInteval)) {
      task()
    }
  }
}

Przykład pokazujący użycie głównej kolejki.

override func viewDidLoad() {
    super.viewDidLoad()
     Threads.performTaskInMainQueue {
        //Update UI
    }
}