如果感觉不错谢谢点赞。
如有问题请写评论,我会尽量及时回复。
如果有没有提到的知识点欢迎提出,我会及时补全。
三种线程操作
Thread: 最轻,灵活度高,可以取消。但是只能有一个传参。
Operation: 操作对象+队列,可以取消,可以自己控制操作对象何时结束。
Grand Central Dispatch: 调度对象,操作对象, 目前没有找到取消方法。
Thread
官方文档Thread
最轻,灵活度最高
- 方法1,使用实例方法直接创建主线程并调用执行。
- 方法2,创建新线程,调用 start() 或 main() 方法执行线程。
- start(), 在新建的线程中运行方法。
- main(), 调用 routine 使方法在主线程中运行。
- cancel(), 将线程状态置为取消状态
- 测试代码
import UIKit
class Test {
func start() {
/// 方法1: 使用类方法创建线程并直接运行
Thread.detachNewThreadSelector(#selector(startAction), toTarget: self, with: nil)
//方式2:使用构造器方法创建线程,最后使用 main() 或者start() 启动线程使用
let myThread = Thread(target: self,
selector: #selector(startAction),
object: nil)
myThread.start()
myThread.main()
}
//定义一个下载图片的方法,线程调用
@objc private func startAction(){
print("执行了线程:\(Thread.current)")
}
}
let myClass = Test()
DispatchQueue.main.async {
myClass.start()
}
Operation
- Test0: 同一队列(OperationQueue)的不同操作对象(Operation)可能会在不同的线程执行;如果添加队列依赖则可以保证在统一线程中运行。
- Test1: 可自己创建 Operation,在 main() 中写自己需要执行的代码。
- 可以将加入队列的的对象调用方法个
operation1.cancel()
取消执行。- Objective-C 可以重载 Operation 中的方法自己控制对象何时运行结束, 关键代码如下
queue.maxConcurrentOperationCount = 1
self.willChangeValue(for: \ActionOperation.isFinished)
self.willfinish = true
self.didChangeValue(for: \ActionOperation.isFinished)
- 测试代码
import UIKit
class Test0 {
func start() {
let operation0 = BlockOperation(block: {
print("队列-0, 执行了, \(Thread.current)")
})
let operation1 = BlockOperation(block: {
print("队列-1, 执行了, \(Thread.current)")
})
//创建一个NSOperationQueue实例并添加operation
let queue = OperationQueue()
print("准备运行队列-0")
queue.addOperation(operation0)
print("准备运行队列-1")
queue.addOperation(operation1)
// operation1.cancel()
}
}
class Test1 {
func start() {
/// 创建线程对象
let actionOperation = ActionOperation()
let nextOperation = BlockOperation {
print("finish!!!")
}
let queue = OperationQueue()
queue.maxConcurrentOperationCount = 1
queue.addOperation(actionOperation)
queue.addOperation(nextOperation)
}
}
class ActionOperation: Operation {
private var willfinish: Bool = false
override func main(){
print("对象执行了\(Thread.current)")
DispatchQueue.main.asyncAfter(deadline: .now() + 3) {
print("我真的执行结束了")
self.willChangeValue(for: \ActionOperation.isFinished)
self.willfinish = true
self.didChangeValue(for: \ActionOperation.isFinished)
}
print("只是方法完毕!!!")
}
override var isFinished: Bool {
print("----\(ffffinish)")
return ffffinish
}
}
let test0 = Test0()
DispatchQueue.main.async {
test0.start()
}
let test1 = Test1()
DispatchQueue.main.async {
test1.start()
}
GCD Group
let queue = DispatchQueue(label: "current", qos: DispatchQoS.userInteractive, attributes: .concurrent)
let gcdGroup = DispatchGroup()
gcdGroup.enter()
queue.async {
print("first")
DispatchQueue.global().asyncAfter(deadline: .now() + 2) {
print("first_after")
gcdGroup.leave()
}
}
gcdGroup.enter()
queue.async {
print("second")
DispatchQueue.global().asyncAfter(deadline: .now() + 2) {
print("second_after")
gcdGroup.leave()
}
}
gcdGroup.notify(queue: queue) {
print("finish")
}
//second
//first
//second_after
//first_after
//finish
Grand Central Dispatch
GCD 获取各种队列的方法
创建串行队列
let serial = DispatchQueue(label: "serialQueue1")
//创建并行队列
let concurrent = DispatchQueue(label: "concurrentQueue1", attributes: .concurrent)
//获取全局队列
let globalQueue = DispatchQueue.global(qos: .default)
//获取主线程队列
let mainQueue = DispatchQueue.main
- 全局队列
- DispatchQueue.global…sync { Code } 同步当前线程执行代码块, Code 代码块中的代码执行完毕后,才会继续执行下面方法, 不会造成亨死锁。
- DispatchQueue.global…async 重新开启线程,执行代码块。
//async异步追加Block块(async函数不做任何等待)
DispatchQueue.global(qos: .default).async {
//处理耗时操作的代码块...
print("do work: \(Thread.current)")
//操作完成,调用主线程来刷新界面
DispatchQueue.main.async {
print("main refresh: \(Thread.current)")
}
}
//添加同步代码块到global队列
//不会造成死锁,但会一直等待代码块执行完毕
print("当前的线程:\(Thread.current)")
serial.async {
DispatchQueue.global(qos: .default).sync {
print("sync1: \(Thread.current)")
sleep(3)
}
print("end")
}
- 一下代码慎用,如果执行环境为主线程,会造成死锁。
DispatchQueue.main.sync {
print("sync2")
}
GCD 操作对象
- 串行异步、同步队列保证在同一线程中顺序执行。
- DispatchWorkItem 非 open 类,不能继承创建子类
let workItem0 = DispatchWorkItem {
print("workItem0::\(Thread.current)")
}
let workItem1 = DispatchWorkItem {
print("workItem1::\(Thread.current)")
}
创建串行队列
let serial = DispatchQueue(label: "serialQueue1")
serial.async(execute: workItem0)
serial.async(execute: workItem1)
//serial.sync(execute: workItem0)
//serial.sync(execute: workItem1)
- 并行同步队列,保证在同一线程中运行,运行顺序确定。
- 并行异步队列,不能保证在同一线程中运行,运行顺序不确定。
let workItem0 = DispatchWorkItem {
print("workItem0::\(Thread.current)")
sleep(0)
}
let workItem1 = DispatchWorkItem {
print("workItem1::\(Thread.current)")
}
//创建并行队列
let concurrent = DispatchQueue(label: "concurrentQueue1", attributes: .concurrent)
DispatchQueue.global().async {
concurrent.async(execute: workItem0)
concurrent.async(execute: workItem1)
//concurrent.sync(execute: workItem0)
//concurrent.sync(execute: workItem1)
}
总结:异步会重新创建线程
您的一举一动都是对我的莫大支持
![](https://i-blog.csdnimg.cn/blog_migrate/6869eceedbeebfa1cbe68ad9660f40c5.png)
![](https://i-blog.csdnimg.cn/blog_migrate/8903311d7505a1be54bce21abf71c9c8.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/554276feeacb99b1d2125edb6509be09.png)