GCD(斯威夫特)

By admin in 4858.com on 2019年4月16日

1.撤除过去的接口

撤回过去的接口

撤销过去的接口

一.撤销过去的接口

4858.com ,  说到 GCD, 我们自然回看起好像 dispatch_GCD(斯威夫特)。async 那样的语法。 GCD
的这些语法模式无论是和 Objc 依旧 斯威夫特 的完整风格都不太打掉。 所以 Swift三 中对它的语法进行了深透的改写。

谈起 GCD, 我们肯定回顾起好像 dispatch_async
那样的语法,那一个语法在swift三中不再适用了,透彻重写了接口比如最常用的,在叁个异步队列中读取数据,
然后再回去主线程更新 UI, 那种操作在新的 斯维夫特 语法中是那般的:

聊到 GCD, 大家自然回顾起类似 dispatch_async 那样的语法。 GCD
的这些语法方式无论是和 Objc 依旧 斯维夫特 的完整风格都不太搭调。 所以 斯维夫特三 中对它的语法进行了通透到底的改写。

  说到 GCD, 大家自然回看起好像 dispatch_async 那样的语法。 GCD
的这几个语法形式无论是和 Objc 依旧 Swift 的完好风格都不太打掉。 所以 Swift三 中对它的语法实行了干净的改写。

比如最常用的,在多少个异步队列中读取数据, 然后再回去主线程更新 UI,
那种操作在新的 斯威夫特 语法中是那般的:

DispatchQueue.global().async { DispatchQueue.main.async { self.label?.text = "finished" } }

比如最常用的,在贰个异步队列中读取数据, 然后再重临主线程更新 UI,
那种操作在新的 斯维夫特 语法中是这么的:

例如最常用的,在八个异步队列中读取数据, 然后再回来主线程更新 UI,
那种操作在新的 斯维夫特 语法中是如此的:

1 DispatchQueue.global().async {
2  
3   DispatchQueue.main.async {
4    
5   self.label?.text = "finished"
6    
7   } 
8    
9 }

变化非常的大, 首先 Swift 三 抛弃了 GCD 从前的函数式调用形式。 引进了
DispatchQueue 那一个类, 第壹行的
DispatchQueue.global().async约等于接纳全局队列进行异步操作。然后在调用
DispatchQueue.main.async使用主线程更新相应的 UI 内容。

DispatchQueue.global().async {        
    DispatchQueue.main.async {                
          self.label?.text = "finished"            
    }    
}
1 DispatchQueue.global().async {
2  
3   DispatchQueue.main.async {
4    
5   self.label?.text = "finished"
6    
7   } 
8    
9 }

 

这一次对 GCD 的纠正还包蕴预先级的概念。 现在我们接纳 Global Queue
的时候,能够运用 DISPATCH_QUEUE_PRIORITY_DEFAULT 或
DISPATCH_QUEUE_PRIORITY_BACKGROUND 等,来钦定队列的先行级。 而新的
GCD 引进了 QoS (Quality of Service)
的概念,映未来代码上边正是优先级所对应的称谓变了, 对应提到如下:

变化十分的大, 首先 Swift 3 抛弃了 GCD 从前的函数式调用格局。 引进了
DispatchQueue 这么些类, 第贰行的 DispatchQueue.global().async
约等于采纳全局队列进行异步操作。然后在调用 DispatchQueue.main.async
使用主线程更新相应的 UI 内容。

 

变化非常大, 首先 Swift 三 废弃了 GCD 从前的函数式调用格局。 引进了
DispatchQueue 那么些类, 第二行的 DispatchQueue.global().async

* DISPATCH_QUEUE_PRIORITY_HIGH: .userInitiated * DISPATCH_QUEUE_PRIORITY_DEFAULT: .default * DISPATCH_QUEUE_PRIORITY_LOW: .utility * DISPATCH_QUEUE_PRIORITY_BACKGROUND: .background

随便从代码长度,已经语法含义上都清楚了壹些吧。 别的, 此番对 GCD
的一字不苟还包涵预先级的概念。 今后大家利用 Global Queue 的时候,能够使用
DISPATCH_QUEUE_PRIORITY_DEFAULT 或
DISPATCH_QUEUE_PRIORITY_BACKGROUND 等,来钦赐队列的先期级。 而新的
GCD 引进了 QoS (Quality of Service)
的定义,展现在代码上面就是优先级所对应的称号变了, 对应涉及如下:

变化极大, 首先 Swift 三 吐弃了 GCD 以前的函数式调用方式。 引进了
DispatchQueue 那么些类, 第三行的 DispatchQueue.global().async

约等于选择全局队列进行异步操作。然后在调用 DispatchQueue.main.async

假定想以万丈优先级试行这一个队列, 那么就足以如此:

DISPATCH_QUEUE_PRIORITY_HIGH:         .userInitiated
DISPATCH_QUEUE_PRIORITY_DEFAULT:      .default
DISPATCH_QUEUE_PRIORITY_LOW:          .utility
DISPATCH_QUEUE_PRIORITY_BACKGROUND:   .background

一定于接纳全局队列举行异步操作。然后在调用 DispatchQueue.main.async

利用主线程更新相应的 UI 内容。

DispatchQueue.global(qos: .userInitiated).async { }

举个例证,借使想以万丈优先级推行那几个行列, 那么就足以那样:

应用主线程更新相应的 UI 内容。

无论是从代码长度,已经语法含义上都清楚了一部分吧。 其余, 此番对 GCD
的校勘还包括预先级的概念。 以后我们选用 Global Queue 的时候,能够使用
DISPATCH_QUEUE_PRIORITY_DEFAULT 或
DISPATCH_QUEUE_PRIORITY_BACKGROUND 等,来钦点队列的预先级。 而新的
GCD 引入了 QoS (Quality of 瑟维斯)
的定义,映以往代码下边就是优先级所对应的名目变了, 对应提到如下:

DispatchWorkItem

DispatchQueue.global(qos: .userInitiated).async {                        
}

任由从代码长度,已经语法含义上都清晰了一部分吗。 其它, 本次对 GCD
的改正还包含预先级的定义。 现在大家利用 Global Queue 的时候,能够采用DISPATCH_QUEUE_PRIORITY_DEFAULT 或
DISPATCH_QUEUE_PRIORITY_BACKGROUND 等,来钦定队列的预先级。 而新的
GCD 引进了 QoS (Quality of Service)
的定义,浮未来代码上面就是优先级所对应的称呼变了, 对应涉及如下:

1 DISPATCH_QUEUE_PRIORITY_HIGH:  .userInitiated
2  
3 DISPATCH_QUEUE_PRIORITY_DEFAULT:  .default
4  
5 DISPATCH_QUEUE_PRIORITY_LOW: .utility
6  
7 DISPATCH_QUEUE_PRIORITY_BACKGROUND: .background

除开直接采取 Global Queue, 还可以够定义 DispatchWorkItem。
DispatchWorkItem 定义了三个操作的内部代码,以及优先级,特性等等。
它能够直接在别的队列中执行:

就此那些优先级概念的变化, 大家也须要留意一下。

1 DISPATCH_QUEUE_PRIORITY_HIGH:  .userInitiated
2  
3 DISPATCH_QUEUE_PRIORITY_DEFAULT:  .default
4  
5 DISPATCH_QUEUE_PRIORITY_LOW: .utility
6  
7 DISPATCH_QUEUE_PRIORITY_BACKGROUND: .background

举个例子,若是想以万丈优先级实施那么些队列, 那么就足以这么:

let queue = DispatchQueue(label: "swift.queue") let workItem = DispatchWorkItem(qos: .userInitiated, flags: .assignCurrentContext) { } queue.async(execute: workItem)

DispatchWorkItem

举个例子,假使想以万丈优先级推行这些队列, 那么就足以如此:

1 DispatchQueue.global(qos: .userInitiated).async {
2  
3  }

dispatch_time_t

除外直接运用 Global Queue, 还足以定义 DispatchWorkItem。
DispatchWorkItem 定义了三个操作的里边代码,以及优先级,天性等等。
它能够一向在此外队列中施行:

1 DispatchQueue.global(qos: .userInitiated).async {
2  
3  }

 

还有3个是对 dispatch_time_t 的改进:

let queue = DispatchQueue(label: “swift.queue”)let workItem =
DispatchWorkItem(qos: .userInitiated, flags: .assignCurrentContext) {
}queue.async(execute: workItem)

 

 

let delay = DispatchTime.now() + .secondsDispatchQueue.main.after(when: delay) { // Do something}

诸如此类的 GCD,看起来更为契合面向对象的风骨了。

 

2. DispatchWorkItem

语法使用起来更为简约。DispatchTime.now() 是现阶段此前, 然后拉长 .seconds
代表 60秒。 再采用 DispatchQueue.main.after 让这么些操作在 60
秒后进行。以前的语法是这一个样子:

dispatch_time_t

2. DispatchWorkItem

  除了直接行使 Global Queue, 还足以定义 DispatchWorkItem。
DispatchWorkItem 定义了叁个操作的中间代码,以及优先级,天性等等。
它能够平昔在别的队列中实行:

let dispatch_time = dispatch_time(DISPATCH_TIME_NOW, Int64(60 * NSEC_PER_SEC))

再有一个是对 dispatch_time_t 的改进:

  除了直接利用 Global Queue, 还足以定义 DispatchWorkItem。
DispatchWorkItem 定义了贰个操作的里边代码,以及优先级,性子等等。
它能够一向在其余队列中施行:

1 let queue = DispatchQueue(label: "swift.queue")
2  
3 let workItem = DispatchWorkItem(qos: .userInitiated, flags: .assignCurrentContext) {
4  
5   }
6    
7 queue.async(execute: workItem)

那样1比,一蹴而就

let delay = DispatchTime.now() + 
.seconds(60)DispatchQueue.main.after(when: delay) {    
// Do something
}
1 let queue = DispatchQueue(label: "swift.queue")
2  
3 let workItem = DispatchWorkItem(qos: .userInitiated, flags: .assignCurrentContext) {
4  
5   }
6    
7 queue.async(execute: workItem)

如此的 GCD,看起来更为适合面向对象的风骨了。

语法使用起来更为简明。DispatchTime.now() 是现阶段事先, 然后增加.seconds(60) 代表 60秒。 再使用 DispatchQueue.main.after 让那么些操作在 60
秒后实践。 相比于事先的 GCD 语法,那就便于驾驭诸多了。
顺手儿把 GCD 从前得到当前光阴的语法贴出来相比较一下:

那般的 GCD,看起来尤其适合面向对象的风格了。

dispatch_time_t

let dispatch_time = dispatch_time(DISPATCH_TIME_NOW, 
Int64(60 * NSEC_PER_SEC))

dispatch_time_t

还有一个是对 dispatch_time_t 的改进:

那样1比, 立见功能哈。 至少上边新的 GCD 语法,
小编大要看了壹眼,就能明了它是什么样意思了。
而上面那么些老的语法,即便不查六柱预测关文书档案的话,第二眼或许没那么轻便看懂了。

再有3个是对 dispatch_time_t 的改进:

1 let delay = DispatchTime.now() + .seconds(60)
2 DispatchQueue.main.after(when: delay) {
3  // Do something
4 }

1 let delay = DispatchTime.now() + .seconds(60)
2 DispatchQueue.main.after(when: delay) {
3  // Do something
4 }

语法使用起来尤其简约。DispatchTime.now() 是现阶段以前, 然后增加.seconds(60) 代表 60秒。 再采用 DispatchQueue.main.after 让这么些操作在 60
秒后进行。 比较于事先的 GCD 语法,那就轻便通晓多数了。

结尾

语法使用起来更为简约。DispatchTime.now() 是当前在此之前, 然后增进.seconds(60) 代表 60秒。 再选用 DispatchQueue.main.after 让那一个操作在 60
秒后实行。 比较于事先的 GCD 语法,那就便于精通繁多了。

顺手儿把 GCD 从前获得当前岁月的语法贴出来相比一下:

Swift 叁 对 GCD 的语法革新要么一点都不小的。 新的语法结构还是很正确的,
当然大诸多情侣应该都习惯了原先的写法,也包括自小编~
所以肯定须要或多或少时刻适应。 希望那篇小说能帮你节省查阅文书档案的时间,
在悠然时刻掌握部分本领点。

顺手儿把 GCD 从前得到当前光阴的语法贴出来相比一下:

let dispatch_time = dispatch_time(DISPATCH_TIME_NOW, Int64(60 * NSEC_PER_SEC))
let dispatch_time = dispatch_time(DISPATCH_TIME_NOW, Int64(60 * NSEC_PER_SEC))

 

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有