2018-03-21 21:17:06 u013466880 阅读数 831

前言

在Swift4.0版本中GCD的常用方法还是有比较大的改动,这里做个简单的整理汇总。

GCD的队列

队列是一种遵循先进先出(FIFO)原则的数据结构,是一种特殊的线性表。

主队列 全局队列 串行队列 并行队列
同步 X 并行同步 串行同步
异步 串行异步 并行异步 串行异步

X 表示禁止这么使用,—— 表示不建议这么使用。

1. 主队列

主队列默认是串行的,另外主队列不能结合同步函数(sync)使用,会造成线程死锁。

override func viewDidLoad() {
      super.viewDidLoad()
      // Do any additional setup after loading the view, typically from a nib.

      let mainQueue = DispatchQueue.main
      mainQueue.sync {
          print("造成当前线程:\(Thread.current)死锁")
      }
}

同时主队列中不应该添加耗时的任务,因为系统的UI相关事务都是在主线程队列中完成的,大量大耗时操作可能会造成卡顿,应该避免。

主队列最常用的方法是当子线程需要通知主线程做一些UI上面的操作时,结合子线程使用:

let queue = DispatchQueue(label: "com.roki.thread")
queue.async {
    // 大量耗时操作
    print("大量耗时操作线程:\(Thread.current)")
    Thread.sleep(forTimeInterval: 2)

    DispatchQueue.main.async {
        //回到主线程操作UI
       print("回到主线程:\(Thread.current)")
    }
}

DF993F5D-6A1D-4869-A7E8-5E9D871915D8.png

2. 全局队列

全局队列是由系统创建的,默认是并行的。全局队列具体运行在哪一个线程,是由系统维护一个线程池,然后挑选其中的一至多条线程来使用。哪条线程会被使用是未知的,是由系统根据当前的并发任务,处理器的负载等情况来决定的。

  • 全局并发同步队列
override func viewDidLoad() {
    super.viewDidLoad()
    // Do any additional setup after loading the view, typically from a nib.

    for i in 1...10 {
        DispatchQueue.global().sync {
            //全局并发同步
            Thread.sleep(forTimeInterval: 2)
            print("线程\(Thread.current)正在执行\(i)号任务")
        }
    }
}

9C11F7B3-7602-4E3B-94A2-0255DFC77077.png

从终端输出我们可以知道任务被顺序执行了,这是因为虽然当前是一个并发队列,但是是同步执行的。同步操作会使得在前一个任务完成后才去执行下一个任务。同步与异步的区别还在于它不会创建新的线程,而是直接在当前线程中执行了相关的任务,当前线程是主线程。同步会阻塞当前线程。

  • 全局并发异步队列
override func viewDidLoad() {
    super.viewDidLoad()
    // Do any additional setup after loading the view, typically from a nib.

    for i in 1...10 {
        DispatchQueue.global().async {
            //全局并发异步
            Thread.sleep(forTimeInterval: 2)
            print("线程\(Thread.current)正在执行\(i)号任务")
        }
    }
}

7D63F60B-3DC4-4071-854E-CCB3E36019E4.png

从终端输出我们可以知道任务被随机执行了,而且被分配在多个子线程中执行的,这符合并发的本质。另外需要注意的是全局并发异步队列,系统在挑选来执行任务的线程的时候,会挑选除了主线程之外的其他线程。

3. 自定义队列

除了上述队列之外,我们还可以使用DispatchQueue创建自定义的队列。
let queue = DispatchQueue(label: "com.roki.thread")
需要注意的是上述创建自定义队列的方式,默认创建的是串行队列。
还有一种创建自定义队列的方法是:

let queue = DispatchQueue(label: "com.custom.thread", qos: DispatchQoS.default, attributes: DispatchQueue.Attributes.concurrent)

iOS10.0 之后上述API更新为:

let queue = DispatchQueue(label: "com.custom.thread", qos: DispatchQoS.default, attributes: DispatchQueue.Attributes.concurrent, autoreleaseFrequency: .workItem, target: nil)

参数说明:
1. label 表示队列标签
2. qos 表示设置队列的优先级
- .userInteractive 需要用户交互的,优先级最高,和主线程一样
- .userInitiated 即将需要,用户期望优先级,优先级高比较高
- .default 默认优先级
- .utility 需要执行一段时间后,再通知用户,优先级低
- *.background 后台执行的,优先级比较低
- *.unspecified 不指定优先级,最低
3. attributes 表示队列类型,默认为串行队列,设置为.concurrent表示并行队列。iOS 10.0之后 attributes 新增.initiallyInactive属性表示当前队列是不活跃的,它需要调用DispatchQueueactivate方法来执行任务。
4. autoreleaseFrequency 表示自动释放频率,设置自动释放机制。
- .inherit 表示不确定,之前默认的行为也是现在的默认值
- .workItem 表示为每个执行的项目创建和排除自动释放池, 项目完成时清理临时对象
- .never 表示GCD不为您管理自动释放池

  • 同步串行队列
    其实同步串行队列,没什么意思的,不管是同步操作还是串行操作都会导致任务被一个一个的执行。这个操作尤其是在主线程执行的时候需要注意,避免造成线程的卡顿。
let queue = DispatchQueue(label: "com.custom.thread")
queue.sync {
   //同步串行队列
}
  • 异步串行队列
    因为是串行队列,即使是异步执行的,任务也是按照顺序依次执行的,但是在子线程中执行的。
let queue = DispatchQueue(label: "com.custom.thread")
queue.async {
   //异步串行队列
}

9D774A76-4F71-49AE-903A-57741B89D1DE.png

根据iOS10.0 之后attributes新增的.initiallyInactive属性,我们可以创建不活跃队列。
- 同步串行不活跃队列

let queue = DispatchQueue(label: "com.custom.thread", qos: DispatchQoS.default, attributes: DispatchQueue.Attributes.initiallyInactive, autoreleaseFrequency: .workItem, target: nil)
queue.sync {
   //同步串行不活跃队列
}
queue.activate()
  • 异步并行不活跃队列
let queue = DispatchQueue(label: "com.custom.thread", qos: DispatchQoS.default, attributes: [.initiallyInactive, .concurrent], autoreleaseFrequency: .workItem, target: nil)
queue.async {
   //异步并行不活跃队列
}
queue.activate()
  • 同步并行队列
    只要涉及到同步的,都不会开启新线程,会在当前线程执行任务,同时任务只能依次执行。
let queue = DispatchQueue(label: "com.custom.thread", qos: DispatchQoS.default, attributes: DispatchQueue.Attributes.concurrent)
for i in 1...10 {
     queue.sync {
        //并发同步队列
        Thread.sleep(forTimeInterval: 2)
        print("线程\(Thread.current)正在执行\(i)号任务")
     }
}

BC7AAE0B-C3FA-4AEB-9593-72E02D4A105F.png

  • 异步并行队列
    异步并行队列就会在多个线程中,随机执行任务。
let queue = DispatchQueue(label: "com.custom.thread", qos: DispatchQoS.default, attributes: DispatchQueue.Attributes.concurrent)
for i in 1...10 {
     queue.async {
        //并发异步
        Thread.sleep(forTimeInterval: 2)
        print("线程\(Thread.current)正在执行\(i)号任务")
     }
}

EA277C08-A7FF-49B5-B26B-73521A51C5CF.png

4. 任务组(DispatchGroup)

如果我们想监听多个任务的执行情况,那么我们需要将任务(异步、同步、串行、并行)都添加到任务组中,然后通过DispatchGroupnotify函数就可以监听是否组内任务都已经完成。

let group = DispatchGroup()
let queue = DispatchQueue(label: "com.custom.thread", qos: DispatchQoS.default, attributes: DispatchQueue.Attributes.concurrent)
for i in 1...10 {
    queue.async(group: group) {
       //并发异步
       Thread.sleep(forTimeInterval: 2)
       print("线程\(Thread.current)正在执行\(i)号任务")
   }
}

group.notify(queue: DispatchQueue.main) {
     // 通知主线程,子线程操作已完成
     print("所有任务都已经完成")
}

05A6287E-81AC-49A0-A277-D53994DB8E0A.png

5. 任务对象(DispatchWorkItem)

在Swift4.0 中使用DispatchWorkItem代替原来OC中的dispatch_block_t。 在DispatchQueue执行操作,除了直接传了一个() -> Void 类型的闭包外,还可以传入一个DispatchWorkItem任务对象。DispatchWorkItem的初始化方法可以配置QosDispatchWorkItemFlags,但是这两个参数都有默认参数,所以也可以只传入一个闭包。
DispatchWorkItemFlags枚举中assignCurrentContext表示QoS根据创建时的context决定。 值得一提的是DispatchWorkItem也有wait方法,使用方式和DispatchGroup一样。调用会等待这个workItem执行完。

let queue = DispatchQueue(label: "com.custom.thread", qos: DispatchQoS.default, attributes: DispatchQueue.Attributes.concurrent)
let workItem = DispatchWorkItem {
     Thread.sleep(forTimeInterval: 2)
     print("线程\(Thread.current)正在执行任务")
}
queue.async(execute: workItem)

print("before waiting")
workItem.wait()
print("after waiting")

A25890FA-C5B3-4000-94D1-D00044663A1A.png

2018-06-14 11:13:12 qq_30932479 阅读数 2968
override func viewDidLoad() {
        super.viewDidLoad()
        //写一个按钮
        btn.frame.size = CGSize(width: 100, height: 50)
        btn.center = view.center
        btn.backgroundColor = .red
        view.addSubview(btn)
        btn.addTarget(self, action: #selector(timeChange), for: .touchUpInside)
        btn.setTitle("发送验证码", for: .normal)
    }

点击事件:

@objc func timeChange() {
        
        var time = 10
        let codeTimer = DispatchSource.makeTimerSource(flags: .init(rawValue: 0), queue: DispatchQueue.global())
        codeTimer.schedule(deadline: .now(), repeating: .milliseconds(1000))  //此处方法与Swift 3.0 不同
        codeTimer.setEventHandler {
            
            time = time - 1
            
            DispatchQueue.main.async {
                self.btn.isEnabled = false
            }
            
            if time < 0 {
                codeTimer.cancel()
                DispatchQueue.main.async {
                    self.btn.isEnabled = true
                    self.btn.setTitle("重新发送", for: .normal)
                }
                return
            }
            
            DispatchQueue.main.async {
                self.btn.setTitle("\(time)", for: .normal)
            }
            
        }
        
        codeTimer.activate()
        
    }

效果图:


注意:点击事件中的 self.btn.isEnabled  self.btn.setTitle 须放在主线程中进行,不然控制台报错,截图如下:


2017-10-23 13:37:47 zxw_xzr 阅读数 13286

Swift 4.0中对 GCD定时器的写法做了很多改进,使之更符合Swift的语言特点,比OC的语法看起来是简明清晰了不少

/// GCD定时器倒计时⏳
///   - timeInterval: 循环间隔时间
///   - repeatCount: 重复次数
///   - handler: 循环事件, 闭包参数: 1. timer, 2. 剩余执行次数
public func DispatchTimer(timeInterval: Double, repeatCount:Int, handler:@escaping (DispatchSourceTimer?, Int)->())
{
    if repeatCount <= 0 {
        return
    }
    let timer = DispatchSource.makeTimerSource(flags: [], queue: DispatchQueue.main)
    var count = repeatCount
    timer.schedule(wallDeadline: .now(), repeating: timeInterval)
    timer.setEventHandler(handler: {
        count -= 1
        DispatchQueue.main.async {
            handler(timer, count)
        }
        if count == 0 {
            timer.cancel()
        }
    }) 
    timer.resume()
}
/// GCD定时器循环操作
///   - timeInterval: 循环间隔时间
///   - handler: 循环事件
public func DispatchTimer(timeInterval: Double, handler:@escaping (DispatchSourceTimer?)->())
{
    let timer = DispatchSource.makeTimerSource(flags: [], queue: DispatchQueue.main)
    timer.schedule(deadline: .now(), repeating: timeInterval)
    timer.setEventHandler {
        DispatchQueue.main.async {
            handler(timer)
        }
    }
    timer.resume()
}
/// GCD延时操作
///   - after: 延迟的时间
///   - handler: 事件
public func DispatchAfter(after: Double, handler:@escaping ()->())
{
    DispatchQueue.main.asyncAfter(deadline: .now() + after) { 
        handler()
    }
}

函数的使用

    override func viewDidLoad() {
        super.viewDidLoad()


        DispatchTimer(timeInterval: 1, repeatCount: 10) { (timer, count) in
                print("剩余执行次数 = \(count)")
            }

        DispatchAfter(after: 5) { 
            print("您好")
        }
    }

打印结果:
剩余执行次数 = 9
剩余执行次数 = 8
剩余执行次数 = 7
剩余执行次数 = 6
剩余执行次数 = 5
您好
剩余执行次数 = 4
剩余执行次数 = 3
剩余执行次数 = 2
剩余执行次数 = 1
剩余执行次数 = 0

2017-10-12 19:24:19 leafgw 阅读数 2708

本次升级由swift2.3->swift4.0

swift2.3升级swift3.0
pravite -> fileprivate
Publice -> open
枚举更换小写
方法名更精简,后面括号移除

gcd方法改变
gcdtimer创建方法返回值类型变了 DispatchSource -> DispatchSourceTimer
setTimer(start: DispatchTime.now() + Double(0) / Double(NSEC_PER_SEC), interval: interval * NSEC_PER_SEC, leeway: 0)
-> scheduleRepeating(deadline: .now(), interval: .seconds(interval))

NS 去掉,AnyObject -> Any
字典用下标取值
let interfaceData = data as NSDictionary
currentSSID = interfaceData["SSID"] as! String

-> 

let interfaceData = data as Dictionary
currentMac = interfaceData.index(forKey: "BSSID" as NSObject) as! String

block需要@escaping修饰

自动布局
snapkit
snp_ -> snp.

网络请求
Alamofire
方法名更换,请求post\get
所有通知更换,枚举更换小写Notification.Task.DidCancel -> Notification.Name.Task.DidCancel

方法的第一个参数加_ ,调用时可省略参数名,不加则需要参数名


一些属性的名字改变isNetworkActivityIndicatorVisible 网络请求的菊花
selecte -> isSelecte
hidden -> isHidden
等等

- - - - - - - - - - - - - - - - - - — - — - - - - - - - - — 

swift3.0 - > swift 4.0

设备相机枚举,类更细分
AVMetadataObjectTypeCode128Code -> AVMetadataObject.ObjectType.code128

AVCaptureSessionPreset1920x1080 -> AVCaptureSession.Preset.hd1920x1080

AVCaptureDevice.defaultDevice(withMediaType: AVMediaTypeVideo) -> AVCaptureDevice.default(for: AVMediaType.video)

不识别前边下方会有红色下划线,提示更详细替换

按command左键点击代码会有弹窗选择进入类详情或帮助,右键直接进详情

#selector方法需要@objc修饰

The use of Swift 3 @objc inference in Swift 4 mode is deprecated警告
build setting swift3 @objc inference 设置为off 
提示信息可以复制

MPI -> Double.pi π
字体属性

所有通知名改为

NSNotification.Name.XXX.rawValue

2016-09-23 13:18:35 u014600626 阅读数 4254

DispatchQueue

首先,dispatch 的全局函数不再写为下划线风格的名称了,它变成了一个更符合 Swift 风格的 DispatchQueue 的样子。

main thread

同样的,你不需要在去用 dispatch_get_main_queue ( ) 来获取主线程,而是 DispatchQueue . main ,那么要放到主线程的代码怎么执行呢?只需要在线程后边使用 . async { } 即可,也就是说,大概是这样:

DispatchQueue.main.async { [weak self] in
      yourcoderunsin mainthread
}

优先级

说完了最基本的东西,我们再来说说其他改变了的东西,比如优先级的名字。

我们知道,GCD 的默认队列优先级有四个:

  • DISPATCH_QUEUE_PRIORITY_HIGH
  • DISPATCH_QUEUE_PRIORITY_DEFAULT
  • DISPATCH_QUEUE_PRIORITY_LOW
  • DISPATCH_QUEUE_PRIORITY_BACKGROUND

现在,新的语法当中,改变了这四个不明不白的优先级名称为更有意义的名字:

  • .userInitialted
  • .default
  • .utility
  • .background

当然,它们的对应关系也就是与顺序相同的:

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

获取一个队列

我们使用 DispatchQueue . global ( ) 获取一个系统的队列,这样的话获取的就是默认 . default 优先级的队列了,如果要获取其他优先级的队列,就使用 DispatchQueue. global ( qos : . userInitiated ) ,最后,我们使用 . async { } 来执行代码:

DispatchQueue.global(qos: .userInitiated).async {
            //your code here
        }

创建一个队列

直接用 DispatchQueue 的初始化器来创建一个队列。最简单直接的办法是这样:

let queue = DispatchQueue(label: "myBackgroundQueue")

复杂一点?你可以指定优先级以及队列类别:

let queue = DispatchQueue(label: "myBackgroundQueue", qos: .userInitiated, attributes: .concurrent)

然后把代码放进去即可:

queue.async {
    print("aaa")
}

队列打组

对于组,现在你可以使用这样的语法直接创建一个组:

let group = DispatchGroup()

至于使用,则是这样的:

let group = DispatchGroup()
 
let queue = DispatchQueue(label: "myBackgroundQueue")
 
queue.async(group:group) {
    print("background working")
}

那么,如果有多个并发队列在同一个组里,我们需要它们完成了再继续呢?

group.wait()

指定时间后执行

很多时候你可能还需要让一些代码在指定的时间后执行,比如动画完成后。这个任务在swift 2.3 很麻烦,不过,在3.0就不一样了:

DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 3.0) {
    print("after!")
}

只需要一句话即可。



其他一些变化,复制过来格式转换有问题,就贴个网址吧: 

http://www.cocoachina.com/swift/20160712/17028.html

Swift3.0学习之GCD

阅读数 518

Swift4.0开发笔记

阅读数 4007

没有更多推荐了,返回首页