将 Do-[Swift版本].swift 拖拽到您的项目中。
dispatch_sync/dispatch_barrier_sync)dispatch_apply)dispatch_after)dispatch_once)dispatch_async 相关的便利函数)Do! 提供轻松访问主队列、全局优先级队列，以及在 OS X 10.10 和 iOS 8.0 及更高版本中可用的全局“服务质量”队列（适当设置回退）。
Do.mainQueue // The "main" dispatch queue.
Do.highPriorityQueue // The global "high priority" dispatch queue.
Do.defaultQueue // The global "default" dispatch queue.
Do.lowPriorityQueue // The global "low priority" dispatch queue.
Do.backgroundQueue // The global "background" dispatch queue.
Do.userInteractiveQueue // The global "user interactive" (super high priority?) dispatch queue.
Do.userInitiatedQueue // The global "user initiated" (equivalent to "high priority") dispatch queue.
Do.utilityQueue // The global "utility" (equivalent to "low priority") dispatch queue.Do! 还提供了一种通过比较标签来检查您是否当前正在特定队列上投递的方法（给您的队列设置标签！）。
if Do.isCurrentQueue(mainQueue) {
print("Hello from the main queue!")
}Do! 在 dispatch_sync 和 dispatch_barrier_sync 之上提供了一个简短且死锁安全（嗯，更安全）的包装器（它使用 Do.isCurrentQueue 以避免这一点，但这仅适用于您尝试符合同一队列，而不是投递树中的更高层级队列）。
Do.sync(someSerialQueue) {
print("Hello world!")
}Do.barrierSync(someConcurrentQueue) {
print("Hello world!")
}更重要的是，Do! 提供了返回值版本，这对于同步资源访问... 是完美的...
let resource: Resource = Do.sync(someSerialQueue) {
// .. heavy work that should happen serially...
return importantResource
}let resource: Resource = Do.barrierSync(someConcurrentQueue) {
// .. heavy work that should block queue...
return importantResource
}.. 或甚至同步属性。
class Variable {
private var _value: Any
var value: Any {
get { return barrierSync(someConcurrentQueue) { self._value } }
set { barrierSync(someConcurrentQueue) { self._value = newValue } }
}
}Do! 在 dispatch_apply 之上提供了一个简洁和安全（再次是 更安全）的包装器。如果目标队列是当前投递队列（或nil），则降级为普通循环。
Do.loop(100, highPriorityQueue) { i in
print(i)
}Do.loop(10) { i in
print(i)
}执行!还提供了一个版本，它接收一个范围而不是迭代次数。
Do.loop(15..<55, highPriorityQueue) { i in
print(i)
}执行!提供了一个围绕dispatch_after的包装器，简洁且默认为主队列...
Do.after(3.0) {
print("Hello world!")
}Do.after(0.5, backgroundQueue) {
print("Hello world!")
}..以及一个返回用于取消安排的块版本。
let cancel = Do.afterCancel(10) {
print("Hello world!")
}
Do.after(2) {
cancel()
}执行!提供了一个简单但强大的调度并发操作（这些操作可能有自己的异步/嵌套调度）的机制，可以将这些操作按顺序或同时处理N个。
static token = Do.ConcurrentToken() // store this somewhere!
// ...
for i in 0..<100 {
Do.concurrent(token, highPriorityQueue) { done in
// some heavy stuff...
done()
}
}
// the 100 operations will process one at a time...static token = Do.ConcurrentToken(limit: 5)
for i in 0..<50 {
Do.concurrent(token, mainQueue) { done in
Do.after(0.5) {
done()
}
}
Do.concurrent(token, backgroundQueue) { done in
Do.after(1.0) {
done()
}
}
}
// the 100 operations (with different logic/queues) will process 5 at a time执行!对dispatch_once提供了一个非常简洁的包装器（使用了一些技巧..因此请注意，它适用且稳定，但不保证是性能最好的解决方案）。
Do.once {
print("Hello world!")
}执行!还提供了一个版本，它存储初始发送的结果，并在随后的发送中简单地返回该值（又是使用技巧）。
for i in 0..<10 {
let message: String = Do.once {
print("Some lazy/heavy stuff that should only happen once ;)")
return "Hello world!"
}
print(message)
}执行!提供了一种简洁的方法，可以在最多每N秒调用一次块（又是使用技巧）。
Do.throttle(3.4) {
print("Hello world!")
}Do.throttle(0.5, backgroundQueue) {
print("Hello world!")
}执行!提供了一个围绕dispatch_async的简洁方便的包装器。就此而言，它很简单。如果要添加其他功能（例如链式调用），我建议使用Async，此版本由duemunk制作。
Do.async(userInitiatedQueue) { ... }Do.barrierAsync(userInitiatedQueue) { ... }let group = dispatch_group_create()
Do.groupAsync(group, userInitiatedQueue) { ... }
Do.barrierGroupAsync(group, userInitiatedQueue) { ... }Do.main { ... }
Do.background { ... }
Do.userInteractive { ... }
Do.userInitiated { ... }