dispatch_once dopo la modifica dell'API Swift 3 GCD

Question

Qual è la nuova sintassi per dispatch_once in Swift dopo le modifiche apportate nella lingua versione 3? La vecchia versione era la seguente.

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

Questi are the changes to libdispatch sono stati creati.

Answer 1

Dal doc:

spedizione
La funzione dispatch_once gratuito non è più disponibile in Swift. In Swift, è possibile utilizzare globali inizializzati pigramente o proprietà statiche e ottenere la stessa sicurezza di thread e garanzie chiamate una volta come dispatch_once fornito. Esempio:

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 2

Mentre usando globali inizializzati pigri può avere senso per qualche inizializzazione una volta, non ha senso per altri tipi. Ha molto senso usare globals pigri inizializzati per cose come i singleton, non ha molto senso per cose come la protezione di un setup swizzle.

Ecco un'implementazione Swift 3 stile di 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() 
    } 
} 

Ecco un esempio di utilizzo:

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

o utilizzando un UUID

private let _onceToken = NSUUID().uuidString 

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

Come siamo attualmente in un tempo di transizione da rapido 2 a 3, ecco un esempio di implementazione di swift 2:

Answer 3

Espandendo la risposta di Tod Cunningham sopra, ho aggiunto un altro metodo che rende il token automaticamente da file, funzione e linea.

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

    public class func once(file: String = #file, function: String = #function, line: Int = #line, block:(Void)->Void) { 
     let token = file + ":" + function + ":" + String(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)->Void) { 
     objc_sync_enter(self) 
     defer { objc_sync_exit(self) } 


     if _onceTracker.contains(token) { 
      return 
     } 

     _onceTracker.append(token) 
     block() 
    } 
} 

Così può essere più semplice di chiamare:

DispatchQueue.once { 
    setupUI() 
} 

e si può ancora indicare un gettone se lo si desidera:

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

Suppongo che si possa ottenere una collisione se si dispone di lo stesso file in due moduli. Peccato che non ci sia #module

Answer 4

È comunque possibile utilizzare se si aggiunge un'intestazione colmare:

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

Poi, in un .m da qualche parte:

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

Ora dovrebbe essere in grado di utilizzare mxcl_dispatch_once da Swift.

Principalmente si dovrebbe usare quello che Apple suggerisce, ma ho avuto alcuni usi legittimi in cui avevo bisogno di dispatch_once con un singolo token in due funzioni e non è coperto da ciò che Apple fornisce invece.

Answer 5

Utilizzare l'approccio costante di classe se si utilizza Swift 1.2 o successivo e l'approccio di struttura nid se è necessario supportare versioni precedenti. Un'esplorazione del pattern Singleton in Swift. Tutti gli approcci seguenti supportano l'inizializzazione pigra e la sicurezza del thread. approccio dispatch_once non è lavorato in rapida 3.0

Approccio A: Classe costante class SingletonA {

static let sharedInstance = SingletonA() 

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

} Approccio B: struct nidificato class SingletonB {

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

} Approccio 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! 
} 

}

Answer 6

Swift 3: Per chi ama classi riutilizzabili (o strutture):

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

Usage:

class MyViewController: UIViewController { 

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

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

} 

---

Aggiornamento (28 aprile 2017): OSSpinLock sostituito con os_unfair_lock avvisi di deprecazione dovuti 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) 
    } 
} 

Answer 7

soluzione più semplice è

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

    self.title = "Hello Lazy Guy" 

    return 
}() 

utilizzato come

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

Answer 8

I have created below function 

func executeOnce(code: @escaping() -> Void) 
     { 
       if UserDefaults.standard.value(forKey: "3333##112233") == nil 
       { 
        code() 
        UserDefaults.standard.setValue("vv", forKey: "3333##112233") 
        UserDefaults.standard.synchronize() 
       } 
     } 

e utilizzare come di seguito

executeOnce { 

     print("onces") 
    }