[swift] Async

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