swift 中多线程的使用- GCD_swift 多线程使用

参考学习文献1
参考学习文献2

理解性的东西上边两篇博客，个人感觉写的还是不错的，可以去看看。本篇博客主要是对有GCD在swift中用法上的一个总结。

• 一.串行队列

• 1.同步串行队列

默认创建是串行队列
label:队列的名称
qos:优先级
sync:同步方式

let queue = DispatchQueue(label: "xibei.manong.queueName",qos: .default)
    queue.sync {
     for i in 0..<5 {
     print("来了一+\(i)")
     }
 }

• 2.异步串行队列

默认创建是串行队列
label:队列的名称
qos:优先级
async:异步方式

let queque1 = DispatchQueue(label: "xibei.manong.queueName",qos: .default)
queque1.async {
    for i in 0..<5 {
    print("来了一+\(i)")
    }

• 二.并发队列

• 1.并发串行

默认创建是串行队列
label:队列的名称
qos:优先级
sync:同步
attributes:此处设置为concurrent(并发队列)

let queue = DispatchQueue(label: "jc.test.log1", qos: .utility, attributes: .concurrent)
     queue.sync  {
    for i in 0..<5 {
       print("来了一+\(i)")
       }
}

• 2.异步并发

默认创建是串行队列
label:队列的名称
qos:优先级
asnc:异步
attributes:此处设置为concurrent(并发队列)

let queue = DispatchQueue(label: "jc.test.log1", qos: .utility, attributes: .concurrent)
     queue.asnc  {
    for i in 0..<5 {
       print("来了一+\(i)")
       }
}

• 三.系统全局队列

let globalQueue = DispatchQueue.global() //  qos: .default
let globalQueue = DispatchQueue.global(qos: .background) // 后台运行级别

• 四.系统主队列

let mainQueue = DispatchQueue.main

• 五.多任务执行完毕统一操作解决方案

• 1.方案一：手动指定enter()与leave()的方式控制任务开始与结束。

let group = DispatchGroup();
let queue1 = DispatchQueue(label: "jc.test.com1", qos: .utility)
let queue2 = DispatchQueue(label: "jc.test.com2", qos: .utility)
let queue3 = DispatchQueue(label: "jc.test.com3", qos: .utility)
group.enter()
queue1.async(group: group){
group.leave()
  print("queue1.async")
}
 
 
group.enter()
queue2.async(group: group){
group.leave()
    print("queue2.async")
}
 
 
group.enter()
queue3.async(group: group){
group.leave()
    print("queue3.async")
}
 
group.notify(queue: DispatchQueue.main){
   print("group.notify")
}

• 2.方案二：信号量去控制

• DispatchSemaphore(value: 2)初始化信号量为2，用来控制并发线程的数量，相当于Operation中的maxConcurrentOperationCount
• semaphore.wait()信号量 -1
• semaphore.signal()信号量为+1
  oc版本写法
  swift 学习

 
let semaphore = DispatchSemaphore(value: 2)//创建信号量
let queue = DispatchQueue(label: "testConcurrentQueue", attributes: .concurrent)
 
queue.async(){
    semaphore.wait(timeout: .distantFuture)
    print("run task 1")
    sleep(1)
    print("complete task 1")
    semaphore.signal()
}
 
queue.async(){
    semaphore.wait(timeout: .distantFuture)
    print("run task 2")
    sleep(1)
    print("complete task 2")
    semaphore.signal()
}
 
queue.async(){
    semaphore.wait(timeout: .distantFuture)
    print("run task 3")
    sleep(1)
    print("complete task 3")
    semaphore.signal()
}
 

• 3.方案三：栅栏函数(barrier)

swift 写法
oc 写法

//创建并行队列
let queue = DispatchQueue.init(label: "test1", qos: .default, attributes: .concurrent, autoreleaseFrequency: .workItem, target: nil)
 
queue.async {//任务一
    for index in 0...3 {
        print("----\(index)---")
    }
}
queue.async {//任务二
    for index in 0...3 {
        print("===\(index)===");
    }
}
 
queue.async(group: nil, qos: .default, flags: .barrier) {
    print("group")
}
 
queue.async {
    print("finish")
}
 

• 六.其他使用

• 1.手动激活队列

let queue = DispatchQueue(label: "jc.test.log", qos: .utility,
attributes: .initiallyInactive)
 
queue.async {
    for i in 0..<5 {
       print("来了一+\(i)")
       }
}
 
queue.async {
     for i in 5..<10 {
       print("来了二+\(i)")
       }
}
 
//需要调用activate，激活队列。
queue.activate()

• 2.延迟操作

在设置调用函数时，asyncAfter有两个及其相同的方法，不同的地方在于参数名有所不同，参照Stack Overflow的解释。
wallDeadline 和 deadline，当系统睡眠后,wallDeadline会继续，但是deadline会被挂起。例如：设置参数为60分钟，当系统睡眠50分钟，wallDeadline会在系统醒来之后10分钟执行，而deadline会在系统醒来之后60分钟执行。向原文作者致敬

let queue = DispatchQueue(label: "jc.test.log")
 
let time = DispatchTimeInterval.seconds(3)
 
queue.asyncAfter(wallDeadline: .now() + time) {
    print("wall dead line done")
}
 
queue.asyncAfter(deadline: .now() + time) {
    print("dead line done")
}

• 3.DispatchWorkItem的使用方式

看这里