[swift] Async_Swift文章/教程_其他教程_编程语言

[swift] Async

2023-02-09 学习力0

核心提示：Asynchttps://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

Async

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

免责声明：本文仅代表作者个人观点，与乐学笔记（本网）无关。其原创性以及文中陈述文字和内容未经本站证实，对本文以及其中全部或者部分内容、文字的真实性、完整性、及时性本站不作任何保证或承诺，请读者仅作参考，并请自行核实相关内容。
本网站有部分内容均转载自其它媒体，转载目的在于传递更多信息，并不代表本网赞同其观点和对其真实性负责，若因作品内容、知识产权、版权和其他问题，请及时提供相关证明等材料并与我们留言联系，本网站将在规定时间内给予删除等相关处理.