dispatch_once nach Änderungen der Swift 3 GCD-API

Was ist die neue Syntax dispatch_oncein Swift nach den Änderungen in Sprachversion 3? Die alte Version war wie folgt.

var token: dispatch_once_t = 0
func test() {
    dispatch_once(&token) {
    }
}

Dies sind die Änderungen an libdispatch , die vorgenommen wurden.

Aus dem Dokument :

Versand
Die kostenlose Funktion dispatch_once ist in Swift nicht mehr verfügbar. In Swift können Sie träge initialisierte Globals oder statische Eigenschaften verwenden und erhalten die gleichen Thread-Sicherheits- und Call-Once-Garantien wie dispatch_once. Beispiel:

let myGlobal: () = { … global contains initialization in a call to a closure … }()
_ = myGlobal  // using myGlobal will invoke the initialization code only the first time it is used.

Während die Verwendung von verzögert initialisierten Globals für eine einmalige Initialisierung sinnvoll sein kann, ist sie für andere Typen nicht sinnvoll. Es ist sehr sinnvoll, faul initialisierte Globals für Dinge wie Singletons zu verwenden. Es ist nicht sehr sinnvoll für Dinge wie das Bewachen eines Swizzle-Setups.

Hier ist eine Swift 3-Implementierung von dispatch_once:

public extension DispatchQueue {

    private static var _onceTracker = [String]()

    /**
     Executes a block of code, associated with a unique token, only once.  The code is thread safe and will
     only execute the code once even in the presence of multithreaded calls.

     - parameter token: A unique reverse DNS style name such as com.vectorform.<name> or a GUID
     - parameter block: Block to execute once
     */
    public class func once(token: String, block:@noescape(Void)->Void) {
        objc_sync_enter(self); defer { objc_sync_exit(self) }

        if _onceTracker.contains(token) {
            return
        }

        _onceTracker.append(token)
        block()
    }
}

Hier ist ein Anwendungsbeispiel:

DispatchQueue.once(token: "com.vectorform.test") {
    print( "Do This Once!" )
}

oder mit einer UUID

private let _onceToken = NSUUID().uuidString

DispatchQueue.once(token: _onceToken) {
    print( "Do This Once!" )
}

Da wir uns derzeit in einer Zeit des Übergangs von Swift 2 zu 3 befinden, ist hier ein Beispiel für die Implementierung von Swift 2:

public class Dispatch
{
    private static var _onceTokenTracker = [String]()

    /**
     Executes a block of code, associated with a unique token, only once.  The code is thread safe and will
     only execute the code once even in the presence of multithreaded calls.

     - parameter token: A unique reverse DNS style name such as com.vectorform.<name> or a GUID
     - parameter block: Block to execute once
     */
    public class func once(token token: String, @noescape block:dispatch_block_t) {
        objc_sync_enter(self); defer { objc_sync_exit(self) }

        if _onceTokenTracker.contains(token) {
            return
        }

        _onceTokenTracker.append(token)
        block()
    }

}

Als Erweiterung der obigen Antwort von Tod Cunningham habe ich eine weitere Methode hinzugefügt, mit der das Token automatisch aus Datei, Funktion und Zeile erstellt wird.

public extension DispatchQueue {
    private static var _onceTracker = [String]()

    public class func once(file: String = #file,
                           function: String = #function,
                           line: Int = #line,
                           block: () -> Void) {
        let token = "\(file):\(function):\(line)"
        once(token: token, block: block)
    }

    /**
     Executes a block of code, associated with a unique token, only once.  The code is thread safe and will
     only execute the code once even in the presence of multithreaded calls.

     - parameter token: A unique reverse DNS style name such as com.vectorform.<name> or a GUID
     - parameter block: Block to execute once
     */
    public class func once(token: String,
                           block: () -> Void) {
        objc_sync_enter(self)
        defer { objc_sync_exit(self) }

        guard !_onceTracker.contains(token) else { return }

        _onceTracker.append(token)
        block()
    }
}

So kann es einfacher sein, Folgendes anzurufen:

DispatchQueue.once {
    setupUI()
}

und Sie können immer noch ein Token angeben, wenn Sie möchten:

DispatchQueue.once(token: "com.hostname.project") {
    setupUI()
}

Ich nehme an, Sie könnten eine Kollision bekommen, wenn Sie dieselbe Datei in zwei Modulen haben. Schade, dass es das nicht gibt#module

Bearbeiten

Antwort von @ Frizlab - Diese Lösung ist nicht garantiert threadsicher. Eine Alternative sollte verwendet werden, wenn dies entscheidend ist

Einfache Lösung ist

lazy var dispatchOnce : Void  = { // or anyName I choose

    self.title = "Hello Lazy Guy"

    return
}()

verwendet wie

override func viewDidLayoutSubviews() {
    super.viewDidLayoutSubviews()
    _ = dispatchOnce
}

Sie können es weiterhin verwenden, wenn Sie einen Bridging-Header hinzufügen:

typedef dispatch_once_t mxcl_dispatch_once_t;
void mxcl_dispatch_once(mxcl_dispatch_once_t *predicate, dispatch_block_t block);

Dann .mirgendwo:

void mxcl_dispatch_once(mxcl_dispatch_once_t *predicate, dispatch_block_t block) {
    dispatch_once(predicate, block);
}

Sie sollten jetzt in der Lage sein, mxcl_dispatch_oncevon Swift zu verwenden.

Meistens sollten Sie stattdessen das verwenden, was Apple vorschlägt, aber ich hatte einige legitime Verwendungszwecke, bei denen ich dispatch_oncemit einem einzigen Token in zwei Funktionen arbeiten musste, und es wird nicht abgedeckt, was Apple stattdessen bereitstellt.

Sie können eine Variablenfunktion der obersten Ebene wie folgt deklarieren:

private var doOnce: ()->() = {
    /* do some work only once per instance */
    return {}
}()

dann nenne das irgendwo:

doOnce()

Swift 3: Für diejenigen, die wiederverwendbare Klassen (oder Strukturen) mögen:

public final class /* struct */ DispatchOnce {
   private var lock: OSSpinLock = OS_SPINLOCK_INIT
   private var isInitialized = false
   public /* mutating */ func perform(block: (Void) -> Void) {
      OSSpinLockLock(&lock)
      if !isInitialized {
         block()
         isInitialized = true
      }
      OSSpinLockUnlock(&lock)
   }
}

Verwendung:

class MyViewController: UIViewController {

   private let /* var */ setUpOnce = DispatchOnce()

   override func viewWillAppear() {
      super.viewWillAppear()
      setUpOnce.perform {
         // Do some work here
         // ...
      }
   }

}

Update (28. April 2017): OSSpinLockErsetzt durch os_unfair_lockfällige Verfallswarnungen in macOS SDK 10.12.

public final class /* struct */ DispatchOnce {
   private var lock = os_unfair_lock()
   private var isInitialized = false
   public /* mutating */ func perform(block: (Void) -> Void) {
      os_unfair_lock_lock(&lock)
      if !isInitialized {
         block()
         isInitialized = true
      }
      os_unfair_lock_unlock(&lock)
   }
}

Ich verbessere die obigen Antworten und erhalte das Ergebnis:

import Foundation
extension DispatchQueue {
    private static var _onceTracker = [AnyHashable]()

    ///only excute once in same file&&func&&line
    public class func onceInLocation(file: String = #file,
                           function: String = #function,
                           line: Int = #line,
                           block: () -> Void) {
        let token = "\(file):\(function):\(line)"
        once(token: token, block: block)
    }

    ///only excute once in same Variable
    public class func onceInVariable(variable:NSObject, block: () -> Void){
        once(token: variable.rawPointer, block: block)
    }
    /**
     Executes a block of code, associated with a unique token, only once.  The code is thread safe and will
     only execute the code once even in the presence of multithreaded calls.

     - parameter token: A unique reverse DNS style name such as com.vectorform.<name> or a GUID
     - parameter block: Block to execute once
     */
    public class func once(token: AnyHashable,block: () -> Void) {
        objc_sync_enter(self)
        defer { objc_sync_exit(self) }

        guard !_onceTracker.contains(token) else { return }

        _onceTracker.append(token)
        block()
    }

}

extension NSObject {
    public var rawPointer:UnsafeMutableRawPointer? {
        get {
            Unmanaged.passUnretained(self).toOpaque()
        }
    }
}

Verwenden Sie den Klassenkonstantenansatz, wenn Sie Swift 1.2 oder höher verwenden, und den verschachtelten Strukturansatz, wenn Sie frühere Versionen unterstützen müssen. Eine Untersuchung des Singleton-Musters in Swift. Alle folgenden Ansätze unterstützen eine verzögerte Initialisierung und Thread-Sicherheit. Der dispatch_once-Ansatz funktioniert in Swift 3.0 nicht

Ansatz A: Klassenkonstante

class SingletonA {

    static let sharedInstance = SingletonA()

    init() {
        println("AAA");
    }

}

Ansatz B: Verschachtelte Struktur

class SingletonB {

    class var sharedInstance: SingletonB {
        struct Static {
            static let instance: SingletonB = SingletonB()
        }
        return Static.instance
    }

}

Ansatz C: dispatch_once

class SingletonC {

    class var sharedInstance: SingletonC {
        struct Static {
            static var onceToken: dispatch_once_t = 0
            static var instance: SingletonC? = nil
        }
        dispatch_once(&Static.onceToken) {
            Static.instance = SingletonC()
        }
        return Static.instance!
    }
}