Async
https://github.com/duemunk/Async
Syntactic sugar in Swift for asynchronous dispatches in Grand Central Dispatch (GCD)
这是一个Swift中GCD的语法糖库。
Async sugar looks like this:
Async使用起来就像这样子：
Async.background {
println("This is run on the background queue")
}.main {
println("This is run on the main queue, after the previous block") }
Instead of the familiar syntax for GCD:
替换了下面的这种显示方式：
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0), {
println("This is run on the background queue")
dispatch_async(dispatch_get_main_queue(), {
println("This is run on the main queue, after the previous block") }) })
Install
pod 'Async', :git => 'https://github.com/duemunk/Async.git'
Benefits
- Less verbose code 更少的冗余代码
- Less code indentation 更少的缩进风
Things you can do
Supports the modern queue classes:
支持常用的queue类：
Async.main {}
Async.userInteractive {}
Async.userInitiated {}
Async.utility {}
Async.background {}
Chain as many blocks as you want:
你可以将不同的block链接起来使用：
Async.userInitiated {
// 1
}.main {
// 2
}.background {
// 3 }.main { // 4 }
Store reference for later chaining:
也可以分开使用：
let backgroundBlock = Async.background {
println("This is run on the background queue") } // Run other code here... // Chain to reference backgroundBlock.main { println("This is run on the \(qos_class_self().description) (expected \(qos_class_main().description)), after the previous block") }
Custom queues:
自定义queue：
let customQueue = dispatch_queue_create("CustomQueueLabel", DISPATCH_QUEUE_CONCURRENT)
let otherCustomQueue = dispatch_queue_create("OtherCustomQueueLabel", DISPATCH_QUEUE_CONCURRENT) Async.customQueue(customQueue) { println("Custom queue") }.customQueue(otherCustomQueue) { println("Other custom queue") }
Dispatch block after delay:
延时执行：
let seconds = 0.5
Async.main(after: seconds) { println("Is called after 0.5 seconds") }.background(after: 0.4) { println("At least 0.4 seconds after previous block, and 0.9 after Async code is called") }
Cancel blocks that aren't already dispatched:
取消没有启动的线程：
// Cancel blocks not yet dispatched
let block1 = Async.background {
// Heavy work
for i in 0...1000 { println("A \(i)") } } let block2 = block1.background { println("B – shouldn't be reached, since cancelled") } Async.main { // Cancel async to allow block1 to begin block1.cancel() // First block is _not_ cancelled block2.cancel() // Second block _is_ cancelled }
Wait for block to finish – an ease way to continue on current queue after background task:
等待一个block运行结束：
let block = Async.background {
// Do stuff
}
// Do other stuff
block.wait()
How does it work
The way it work is by using the new notification API for GCD introduced in OS X 10.10 and iOS 8. Each chaining block is called when the previous queue has finished.
本库使用了 iOS 8 提供的通知 API 来完成相关功能，每一个block都会在上一个block执行完了之后继续执行：
let previousBlock = {}
let chainingBlock = {}
let dispatchQueueForChainingBlock = ... // Use the GCD API to extend the blocks let _previousBlock = dispatch_block_create(DISPATCH_BLOCK_INHERIT_QOS_CLASS, previousBlock) let _chainingBlock = dispatch_block_create(DISPATCH_BLOCK_INHERIT_QOS_CLASS, chainingBlock) // Use the GCD API to call back when finishing the "previous" block dispatch_block_notify(_previousBlock, dispatchQueueForChainingBlock, _chainingBlock)
The syntax part of the chaining works by having class methods on the Async object e.g. Async.main {} which returns a struct. The struct has matching methods e.g. theStruct.main {}.
Known bugs
Modern GCD queues don't work as expected in the iOS Simulator. See issues 13, 22.
Known improvements
The dispatch_block_t can't be extended. Workaround used: Wrap dispatch_block_t in a struct that takes the block as a property.
Bonus stuff
There is also a wrapper for dispatch_apply() for quick parallelisation of a for loop.
Apply.background(100) { i in
// Do stuff e.g. println(i)
}
Note that this function returns after the block has been run all 100 times i.e. it is not asynchronous. For asynchronous behaviour, wrap it in a an Async block like Async.main{ Apply.background(100) { ... } }.
