一次性执行(dispatch_once_t)
实际开发中有时我们需要某个方法只执行一次，而且要保证线程是安全的，那么dispatch_once_t无疑是很好的选择。
- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
[self onceTest];
}
- (void)onceTest {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
NSLog(@"%@", [NSThread currentThread]);
});
}
执行在主线程上
- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
dispatch_async(dispatch_get_global_queue(0, 0), ^{
[self onceTest];
});
}
执行在当前线程上
- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
for(int i = 0; i< 10; i++) {
dispatch_async(dispatch_get_global_queue(0, 0), ^{
[self onceTest];
});
}
}
线程是安全的，同时开启多个任务执行once仍然只执行一次
实际开发中once最常用在创建单例的对象上
#import
@interface JYPerson : NSObject
+ (instancetype)sharedPerson;
@end
#import "JYPerson.h"
@implementation JYPerson
// 定义一个静态变量，保证内存中只有一个副本，而且是保存在静态区直到程序退出才销毁
static id instance;
// 提供一个全局的访问方法（补充：有一个约定，所有的单例都是以 shared + 类名 格式定义）
+ (instancetype)sharedPerson {
// 用dispatch_once的目的：保证对象只会被初始化（init）一次，切线程是安全的
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
instance = [[self alloc] init];
});
return instance;
}
// 重写allocWihtZone方法保证，对象只会被实例化一次，只分配一次内存空间
+ (instancetype)allocWithZone:(struct _NSZone *)zone {
// 用dispatch_once的目的：在多线程运行在保证allocWithZone只调用一次，即内存只分配一次
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
instance = [super allocWithZone:zone];
});
return instance;
}
- (id)copyWithZone:(NSZone *)zone {
// return [[self.class allocWithZone:zone] init];
// 对象方法，说明拷贝的源已经存在 => instance 就一定已经被实例化过，所以这里直接返回实例instance
return instance;
}
@end
顺便介绍下Swift中单利写法(dispatch_once_t在swift中被废弃了)
import UIKit
class JYPerson: NSObject {
static let shareInstance: JYPerson = {
return JYPerson()
}()
}
延时操作
// OC
/**
参数1: dispatch_time_t when
多少纳秒之后执行
参数2: dispatch_queue_t queue
执行任务的队列
参数3: dispatch_block_t block
要执行的任务
*/
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)( * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// 要执行的任务
});
// Swift
func test2() -> () {
// 原先的dispatch_time_t现在由DispatchTime对象表示。可以用静态方法now获得当前时间，然后再通过加上一个。DispatchTimeInterval枚举来获得一个需要延迟的时间
print("操作一")
// let delay = DispatchTime.now() + DispatchTimeInterval.seconds(3)
// 这里也可以直接加上一个秒数
let delay = DispatchTime.now() + 3
DispatchQueue.main.asyncAfter(deadline: delay) {
print("操作二：延迟了3s执行")
}
}
调度组(Dispatch_groups)
Dispatch Group 会在整个组的任务都完成时发出通知，这些任务可以是同步的，也可以是异步的，即便在不同的队列也行。对多个异步任务的完成进行监控的问题，这无疑是一个非常好的选择。
因为被监控的任务可能在不同的队列，因此用一个 dispatch_group_t 的实例来记下这些不同的任务。
当组中所有的事件都完成时，GCD 的 API 提供了两种通知方式。
用法一
利用 dispatch_group_wait ，它会阻塞当前线程，直到组里面所有的任务都完成或者等到某个超时发生。
因为你在使用的是同步的 dispatch_group_wait ，它会阻塞当前线程，所以你要用 dispatch_async 将整个方法放入后台队列以避免阻塞主线程。
// OC
- (void)groupTest {
dispatch_async(dispatch_get_global_queue(0, 0), ^{
// 创建一个dispatch_group
dispatch_group_t group = dispatch_group_create();
// 手动通知进入dispatch_group_t(你必须保证 dispatch_group_enter 和 dispatch_group_leave 成对出现，否则你可能会遇到诡异的崩溃问题)
dispatch_group_enter(group);
NSLog(@"任务1");
[NSThread sleepForTimeInterval:3.0];
NSLog(@"任务1");
NSLog(@"任务1");
// 手动通知结束dispatch_group_t
dispatch_group_leave(group);
// 一直等待直到dispatch_group_t中所有任务执行完毕
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
dispatch_async(dispatch_get_main_queue(), ^{
NSLog(@"拉回主线程刷新UI");
});
});
}
// Swift
func groupTest() -> () {
DispatchQueue.global().async {
// 创建一个dispatch_group
let group = DispatchGroup();
// 手动通知进入dispatch_group_t(你必须保证 dispatch_group_enter 和 dispatch_group_leave 成对出现，否则你可能会遇到诡异的崩溃问题)
group.enter()
print("任务1")
print("任务2")
print("任务3")
group.leave()
// 一直等待直到dispatch_group_t中所有任务执行完毕
group.wait()
DispatchQueue.main.async(execute: {
print("拉回主线程刷新UI")
})
}
}
控制台输出结果
[1670:108365] 任务1
[1670:108365] 任务2
[1670:108365] 任务3
[1670:108304] 拉回主线程刷新UI
基本实现过程：
创建一个group ，执行groupenter 和 leave 中间的代码 ，然后再利用dispatch_group_wait 让线程阻塞在这里 一直等待，最后再去执行刷新UI或者处理group结果的部分
用法二
然而，用阻塞线程这种方法显得不是那么友好 ，我们来看看第二种 ，不阻塞线程的方法：dispatch_group_notify
// OC
- (void)groupTest {
dispatch_async(dispatch_get_global_queue(0, 0), ^{
// 创建一个dispatch_group
dispatch_group_t group = dispatch_group_create();
// 手动通知进入dispatch_group_t(你必须保证 dispatch_group_enter 和 dispatch_group_leave 成对出现，否则你可能会遇到诡异的崩溃问题)
dispatch_group_enter(group);
NSLog(@"任务1");
[NSThread sleepForTimeInterval:3.0];
NSLog(@"任务2");
NSLog(@"任务3");
// 手动通知结束dispatch_group_t
dispatch_group_leave(group);
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
NSLog(@"拉回主线程刷新UI");
});
});
}
// Swift
func groupTest() -> () {
DispatchQueue.global().async {
// 创建一个dispatch_group
let group = DispatchGroup();
// 手动通知进入dispatch_group_t(你必须保证 dispatch_group_enter 和 dispatch_group_leave 成对出现，否则你可能会遇到诡异的崩溃问题)
group.enter()
print("任务1")
print("任务2")
print("任务3")
group.leave()
let workItem = DispatchWorkItem(block: {
print("拉回主线程刷新UI")
})
group.notify(queue: DispatchQueue.main, work: workItem)
}
}
控制台输出结果
[1670:108365] 任务1
[1670:108365] 任务2
[1670:108365] 任务3
[1670:108304] 拉回主线程刷新UI
用法三(平时开发最常用)
// OC
- (void)groupTest {
dispatch_async(dispatch_get_global_queue(0, 0), ^{
// 创建一个dispatch_group
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
NSLog(@"任务1");
});
dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
NSLog(@"任务2");
});
dispatch_group_notify(group, dispatch_get_global_queue(0, 0), ^{
NSLog(@"任务3");
});
});
}
// Swift
func groupTest() -> () {
DispatchQueue.global().async {
// 创建一个dispatch_group
let group = DispatchGroup()
let queueOne = DispatchQueue(label: "queueOne")
queueOne.async(group: group) {
print("任务1")
}
let queueTwo = DispatchQueue(label: "queueTwo")
queueTwo.async(group: group) {
print("任务2")
}
group.notify(queue: DispatchQueue.main) {
print("任务3")
}
}
}
控制台输出结果
任务1
任务2
任务3
或者
任务2
任务1
任务3
任务1和任务2是异步的所以先后顺序不可控，任务3只有在group中所有任务执行完毕调用
dispatch_barrier
在并行队列中，为了保持某些任务的顺序，需要等待一些任务完成后才能继续进行，使用 barrier 来等待之前任务完成，避免数据竞争等问题。假设我们有一个并发的队列用来读写一个数据对象。如果这个队列里的操作是读的，那么可以多个同时进行。如果有写的操作，则必须保证在执行写入操作时，不会有读取操作在执行，必须等待写入完成后才能读取，否则就可能会出现读到的数据不对。OC用dipatch_barrier实现。Swift中用DispatchWorkItemFlags实现。
// OC
- (void)barrierTest {
dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
NSLog(@"任务1");
});
dispatch_async(queue, ^{
NSLog(@"任务2");
[NSThread sleepForTimeInterval:2.0];
});
dispatch_barrier_async(queue, ^{
NSLog(@"barrier测试");
});
dispatch_async(queue, ^{
NSLog(@"任务3");
});
}
// Swift
func barrierTest() -> () {
let queue = DispatchQueue(label: "queue", attributes: .concurrent)
queue.async {
print("任务1")
}
queue.async {
print("任务2")
Thread.sleep(forTimeInterval: 2.0)
}
let barrierWorkItm = DispatchWorkItem(flags: .barrier) {
print("barrier测试")
}
queue.async(execute: barrierWorkItm)
queue.async {
print("任务3")
}
}
控制台输出结果
任务1
任务2
barrier测试
任务3
或
任务2
任务1
barrier测试
任务3
任务1和任务2是异步的所以先后顺序不可控，barrier会等待当前队列中先于自己添加的任务完成再执行，并阻塞当前线程，等待barrier函数执行完毕当前线程才恢复之前的动作继续执行，任务3只barrier函数执行完毕后才能调用。
注意：使用 dispatch_barrier_async ，该函数只能搭配自定义并行队列 dispatch_queue_t 使用。不能使用： dispatch_get_global_queue ，否则 dispatch_barrier_async 的作用会和 dispatch_async 的作用一模一样。
dispatch_apply
作用：按指定的次数将指定的Block追加到指定的Dispatch Queue中,并等到全部的处理执行结束(类似for循环)
并行队列
- (void)apply {
dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_apply(5, queue, ^(size_t index) {
NSLog(@"当前线程：%@, index: %zu",[NSThread currentThread], (index + 1));
});
dispatch_async(dispatch_get_global_queue(0, 0), ^{
NSLog(@"done");
});
}
控制台输出结果：并行队列上是并发执行的，但并非所有任务都开辟新线程，也有在主线程中完成的。dispatch_apply会阻塞线程，直到dispatch_apply函数执行完毕才继续往下走，所有done最后打印
当前线程：
当前线程：
当前线程：
当前线程：
当前线程：
done
串行队列
- (void)applyTest {
dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);
dispatch_apply(5, queue, ^(size_t index) {
NSLog(@"当前线程：%@, index: %zu",[NSThread currentThread], (index + 1));
});
dispatch_async(dispatch_get_global_queue(0, 0), ^{
NSLog(@"done");
});
}
控制台输出结果：
当前线程：
当前线程：
当前线程：
当前线程：
当前线程：
done