Swift 3 GCD API更改后的dispatch_once

Question

dispatch_once在语言版本3中进行更改后,Swift中的新语法是什么？旧版本如下.

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

这些是对libdispatch的更改.

Answer 1

虽然使用延迟初始化全局变量对于某些一次初始化是有意义的,但对其他类型没有意义.将懒惰的初始化全局变量用于单例这样的事情是很有意义的,它对于保护混合设置这样的事情没有多大意义.

这是dispatch_once的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()
    }
}

以下是一个示例用法:

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

或使用UUID

private let _onceToken = NSUUID().uuidString

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

由于我们目前正处于从swift 2过渡到3的时间,这里有一个示例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

来自doc:

Dispatch
Swift中不再提供免费函数dispatch_once.在Swift中,您可以使用延迟初始化的全局变量或静态属性,并获得与提供的dispatch_once相同的线程安全性和一次性保证.例:

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

扩展了Tod Cunningham上面的答案,我添加了另一种方法,可以自动从文件,函数和行中生成令牌.

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

因此可以更简单地调用:

DispatchQueue.once {
    setupUI()
}

如果您愿意,您仍然可以指定令牌:

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

如果你在两个模块中有相同的文件,我想你可能会发生碰撞.太糟糕了没有#module

Answer 4

编辑

@Frizlab的回答 - 这个解决方案不保证是线程安全的.如果这是至关重要的,应该使用替代方案

简单的解决方案

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

    self.title = "Hello Lazy Guy"

    return
}()

用过像

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

Answer 5

如果添加桥接标题,您仍然可以使用它:

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

然后在.m某个地方:

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

你现在应该可以使用mxcl_dispatch_onceSwift了.

大多数情况下你应该使用Apple提出的建议,但是我有一些合法的用途,我需要dispatch_once在两个函数中使用单个令牌,而Apple没有提供它.

Answer 6

Swift 3:对于喜欢可重用类(或结构)的人:

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

用法:

class MyViewController: UIViewController {

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

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

}

更新(2017年4月28日):OSSpinLock替换为os_unfair_lockmacOS 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

您可以这样声明一个顶级变量函数：

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

然后在任何地方调用：

doOnce()