创建DispatchQueue
// 与当前进程的主线程相关联的调度队列, 即主队列。
class var main: DispatchQueue { get }
// 返回一个系统全局队列
class func global(qos: DispatchQoS.QoSClass = .default) -> DispatchQueue
/**
* 创建一个派发队列。
* label：队列的唯一标识。
* qos ：决定了系统安排任务执行的优先级。
* attributes ： 执行队列的执行方式，串行还是并行。
* autoreleaseFrequency ： 指示队列自动释放对象的频率的常量。
* target ： 计划执行blocks的目标队列。如果希望系统提供适合当前对象的队列，请指定DISPATCH_TARGET_QUEUE_DEFAULT。
*/
convenience init(label: String, qos: DispatchQoS = .unspecified, attributes: DispatchQueue.Attributes = [], autoreleaseFrequency: DispatchQueue.AutoreleaseFrequency = .inherit, target: DispatchQueue? = nil)
// 获取主队列
let mainQueue = DispatchQueue.main
// 获取全局队列
let globalQueue = DispatchQueue.global()
// 自定义一个并行队列
let customConcurrentQueue = DispatchQueue(label: "com.queue.concurrent", qos: .unspecified, attributes: [.concurrent], autoreleaseFrequency: .inherit, target: nil)
// 自定义一个串行队列，attributes不赋值即是串行。
let serialConcurrentQueue = DispatchQueue(label: "com.queue.serial", qos: .unspecified, attributes: [], autoreleaseFrequency: .inherit, target: nil)
print("mainQueue is \(mainQueue)")
print("globalQueue is \(globalQueue)")
print("customConcurrentQueue is \(customConcurrentQueue)")
print("serialConcurrentQueue is \(serialConcurrentQueue)")
输出结果：
mainQueue is <OS_dispatch_queue_main: com.apple.main-thread>
globalQueue is <OS_dispatch_queue_global: com.apple.root.default-qos>
customConcurrentQueue is <OS_dispatch_queue_concurrent: com.queue.concurrent>
serialConcurrentQueue is <OS_dispatch_queue_serial: com.queue.serial>
//异步执行任务主要有以下这些方法:
//wallDeadline 和 deadline，当系统睡眠后,wallDeadline会继续，但是deadline会被挂起。例如：设置参数为60分钟，当系统睡眠50分钟，wallDeadline会在系统醒来之后10分钟执行，而deadline会在系统醒来之后60分钟执行。
// 立即执行派发的任务，并立即return。
func async(execute: DispatchWorkItem)
// 在指定的时间执行派发的任务，并立即return。
func asyncAfter(deadline: DispatchTime, execute: DispatchWorkItem)
// 在指定的时间执行派发的任务的block，并立即return。
func asyncAfter(deadline: DispatchTime, qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], execute work: @escaping @convention(block) () -> Void)
// 在指定的时间后执行派发的任务，并立即return。
func asyncAfter(wallDeadline: DispatchWallTime, execute: DispatchWorkItem)
// 在指定的时间后执行派发的任务的block，并立即return。
func asyncAfter(wallDeadline: DispatchWallTime, qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], execute work: @escaping @convention(block) () -> Void)
同步任务+串行队列
(没有开启新线程，串行执行任务，当前线程(主线程)中运行)
let queue1 = DispatchQueue(label: "queue")
print("begin")
queue1.sync {
print("线程1运行")
}
queue1.sync {
print("线程2运行")
}
print("end")
/*
begin
线程1运行
线程2运行
end
*/
同步任务+并发队列
(没有开启新线程，串行执行任务，当前线程(主线程)中运行)
let queue2 = DispatchQueue(label: "queue1", attributes: .concurrent)
print("begin")
queue2.sync {
print("线程1运行")
}
queue2.sync {
print("线程2运行")
}
print("end")
/*
begin
线程1运行
线程2运行
end
*/
异步任务+串行队列
(开启1条新线程，串行执行任务，开启1条新线程中运行)
let queue3 = DispatchQueue(label: "queue")
print("begin")
queue3.async {
print("线程1运行")
}
queue3.async {
print("线程2运行")
}
print("end")
/*
begin
end
线程1运行
线程2运行
*/
异步任务+并发队列
(开启2条新线程，并发执行任务，2条新线程中运行)
let queue4 = DispatchQueue(label: "queue1", attributes: .concurrent)
print("begin")
queue4.async {
print("线程1运行")
}
queue4.async {
print("线程2运行")
}
print("end")
/*
begin
end
线程1运行
线程2运行
*/
项目中用到的
//1.延迟执行
//DispatchTime.now() 获取当前时间
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 3) {
//需要进行的操作
}
//2.异步进行耗时操作,主线程进行用户交互以及刷新UI的操作
//开启一个全局的异步队列
DispatchQueue.global().async {
//耗时操作
DispatchQueue.main.async {
//进行UI刷新和用户交互
}
}
//3.处理多数据请求,所有请求完毕进行UI更新
//创建工作组
let workingGroup = DispatchGroup()
//创建队列
let workingQueue = DispatchQueue(label: "requestData", attributes: .concurrent)
//第一个网络请求
workingGroup.enter()
workingQueue.async {
//进行数据请求1
workingGroup.leave()
}
//第二个网络请求
workingGroup.enter()
workingQueue.async {
//进行数据请求2
workingGroup.leave()
}
//请求完毕
workingGroup.notify(queue: .main) {
//进行UI的更新
}
信号量
相当于一把锁，信号量为0则阻塞线程，大于0则不会阻塞。则我们通过改变信号量的值，来控制是否阻塞线程，从而达到线程同步
// 创建一个信号，value：信号量
let semaphore = DispatchSemaphore.init(value: <#T##Int#>)
// 某个信号进行等待或等待降低信号量,只有当信号量大于0时才会停止等待，继续向下执行
semaphore.wait()
// 使某个信号的信号量+1
semaphore.signal()
func semaphore_demo() {
let queue = DispatchQueue.global()
//创建信号量 值为1 意思是最大并发数为1，任务只能一个接一个执行
let semaphore = DispatchSemaphore.init(value: 1)
//此时信号量为1，无需等待，向下执行 信号量 1->0
semaphore.wait()
queue.asyncAfter(deadline: .now() + 4) {
print("1111")
//延迟4秒后输出1111，释放信号量，信号量 从0->1
semaphore.signal()
}
//延迟4秒输出1111后，此时信号量为1，继续向下执行 同上操作。。。
semaphore.wait()
queue.asyncAfter(deadline: .now() + 10) {
print("2222")
semaphore.signal()
}
semaphore.wait()
queue.asyncAfter(deadline: .now() + 2) {
print("3333")
semaphore.signal()
}
semaphore.wait()
queue.asyncAfter(deadline: .now() + 1) {
print("4444")
semaphore.signal()
}
semaphore.wait()
queue.asyncAfter(deadline: .now() + 6) {
print("5555")
semaphore.signal()
}
semaphore.wait()
print("任务全部完成")
semaphore.signal()
}
输出
1111
2222
3333
4444
5555
任务全部完成
