swift GCD的简单使用

  • 回到主线程
1
2
3
DispatchQueue.main.async {
   //            print("这里是主线程")
}

 

  • 延时执行
1
2
3
4
let deadline = DispatchTime.now() + 5.0
DispatchQueue.global().asyncAfter(deadline: deadline) {
    //            print("这里是延迟做的事情")
}
  • 开启一个异步线程
1
2
3
DispatchQueue.main.async {
    print("开新异步线程执行")
}

 

  •  开启一个同步线程
1
2
3
DispatchQueue.global().sync {
             
}
  •  线程优先级
1
2
3
4
5
6
7
var queue: DispatchQueue = DispatchQueue.global()//
//DispatchQueue.GlobalQueuePriority 有四中选择 high,`default`,low,background
queue = DispatchQueue.global(priority: DispatchQueue.GlobalQueuePriority.background)// 后台执行
// 异步执行队列任务
queue.async {
    //  print("开新线程执行")
}

 

  •  分组执行
1
2
3
4
5
6
7
8
9
10
11
12
let group = DispatchGroup()
 queue = DispatchQueue.global(priority: DispatchQueue.GlobalQueuePriority.default)// 默认优先级执行
 for i in 0 ..< 10 {
     //异步执行队列任务
     queue.async(group: group, execute: {
         print("queue.async(group: group \(i)")
     })
 }
 // 分组队列执行完毕后执行
 group.notify(queue: queue) {
     print("dispatch_group_notify")
 }

 

  • 串行队列:只有一个线程,加入到队列中的操作按添加顺序依次执行。
1
2
3
4
5
6
7
let serialQueue = DispatchQueue(label: "yangj", attributes: [])
 for i in 0 ..< 10 {
     //异步执行队列任务
     serialQueue.async {
         print("serialQueue.async \(i)")
     }
 }

 

  • 并发队列:有多个线程,操作进来之后它会将这些队列安排在可用的处理器上,同时保证先进来的任务优先处理。
1
2
3
4
5
6
7
let globalQueue = DispatchQueue.global(priority: DispatchQueue.GlobalQueuePriority.default)
for i in 0 ..< 10 {
    //异步执行队列任务
    globalQueue.async {
        print("globalQueue.async \(i)")
    }
}
  •  信号量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//DispatchSemaphore 因为信号量值为1,所以一次只能执行一个
 let semaphore = DispatchSemaphore(value: 1)
 let queue = DispatchQueue.global()
 queue.async {
     semaphore.wait()
     let deadline = DispatchTime.now() + 3.0
     DispatchQueue.global().asyncAfter(deadline: deadline) {
         print("-----------------1");
         semaphore.signal()
     }
      
 }
 queue.async {
     semaphore.wait()
     let deadline = DispatchTime.now() + 10.0
     DispatchQueue.global().asyncAfter(deadline: deadline) {
          print("-----------------2");
          semaphore.signal()
     }
      
 }
 queue.async {
     semaphore.wait()
     let deadline = DispatchTime.now() + 2.0
     DispatchQueue.global().asyncAfter(deadline: deadline) {
         print("-----------------3");
         semaphore.signal()
     }
      
 }

 

  • oc中dispatch_group_enter的使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// 创建调度组
let workingGroup = DispatchGroup()
// 创建多列
let workingQueue = DispatchQueue(label: "request_queue")
 
// 模拟异步发送网络请求 A
// 入组
workingGroup.enter()
workingQueue.async {
    Thread.sleep(forTimeInterval: 1)
    print("接口 A 数据请求完成")
    // 出组
    workingGroup.leave()
}
 
// 模拟异步发送网络请求 B
// 入组
workingGroup.enter()
workingQueue.async {
    Thread.sleep(forTimeInterval: 1)
    print("接口 B 数据请求完成")
    // 出组
    workingGroup.leave()
}
 
print("我是最开始执行的,异步操作里的打印后执行")
 
// 调度组里的任务都执行完毕
workingGroup.notify(queue: workingQueue) {
    print("接口 A 和接口 B 的数据请求都已经完毕!, 开始合并两个接口的数据")
}

 

posted @   新年新气象  阅读(1102)  评论(0编辑  收藏  举报
努力加载评论中...
点击右上角即可分享
微信分享提示