dispatch_once après les changements de l'API GCD de Swift 3

Question

Quelle est la nouvelle syntaxe pour dispatch_once en Swift après les changements apportés dans la version 3 du langage ? L'ancienne version était la suivante.

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

Ces sont les modifications apportées à libdispatch qui ont été faites.

Answer 1

Si l'utilisation de globaux initialisés paresseusement peut être judicieuse pour une initialisation ponctuelle, elle ne l'est pas pour d'autres types. L'utilisation de globaux initialisés paresseusement est très utile pour des choses comme les singletons, mais elle n'est pas très utile pour des choses comme la garde d'une configuration de swizzle.

Voici une implémentation de dispatch_once à la manière de Swift 3 :

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

Voici un exemple d'utilisation :

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

ou en utilisant un UUID

private let _onceToken = NSUUID().uuidString

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

Comme nous sommes actuellement en période de transition de swift 2 à 3, voici un exemple de mise en œuvre de 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()
    }

}

Answer 2

A partir de la doc :

Envoi
La fonction libre dispatch_once n'est plus disponible en Swift. En Swift, vous pouvez utiliser des globaux initialisés paresseusement ou des objets statiques de type et obtenir les mêmes garanties de thread-safety et de called-once que dispatch_once. Exemple :

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.

Answer 3

En développant la réponse de Tod Cunningham ci-dessus, j'ai ajouté une autre méthode qui crée automatiquement le jeton à partir du fichier, de la fonction et de la ligne.

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

Il peut donc être plus simple d'appeler :

DispatchQueue.once {
    setupUI()
}

et vous pouvez toujours spécifier un jeton si vous le souhaitez :

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

Je suppose qu'il peut y avoir une collision si le même fichier se trouve dans deux modules. Dommage qu'il n'y ait pas de #module

Answer 4

Editar

Réponse de @Frizlab - cette solution n'est pas garantie pour la sécurité des threads. Une alternative devrait être utilisée si cela est crucial

La solution simple est la suivante

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

    self.title = "Hello Lazy Guy"

    return
}()

utilisé comme

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

Answer 5

Vous pouvez toujours l'utiliser si vous ajoutez un en-tête de pontage :

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

Ensuite, dans un .m quelque part :

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

Vous devriez maintenant être en mesure d'utiliser mxcl_dispatch_once de Swift.

La plupart du temps, vous devriez utiliser ce qu'Apple suggère à la place, mais j'ai eu quelques utilisations légitimes où j'ai eu besoin de dispatch_once avec un seul jeton dans deux fonctions et il n'est pas couvert par ce qu'Apple fournit à la place.